git-coco 0.19.0 → 0.20.0

package/dist/index.esm.mjs

@@ -18,13 +18,13 @@ import prettyMilliseconds from 'pretty-ms';
 import { ChatAnthropic } from '@langchain/anthropic';
 import { ChatOllama } from '@langchain/ollama';
 import { ChatOpenAI } from '@langchain/openai';
-import { StructuredOutputParser, BaseOutputParser, OutputParserException, StringOutputParser } from '@langchain/core/output_parsers';
-import { simpleGit } from 'simple-git';
+import { BaseOutputParser, OutputParserException, StructuredOutputParser, StringOutputParser } from '@langchain/core/output_parsers';
 import { BaseLangChain, BaseLanguageModel } from '@langchain/core/language_models/base';
 import { ensureConfig, Runnable } from '@langchain/core/runnables';
 import { RUN_KEY } from '@langchain/core/outputs';
 import { CallbackManager, parseCallbackConfigArg } from '@langchain/core/callbacks/manager';
 import '@langchain/core/utils/json_patch';
+import { simpleGit } from 'simple-git';
 import pQueue from 'p-queue';
 import { Document, BaseDocumentTransformer } from '@langchain/core/documents';
 import { createTwoFilesPatch } from 'diff';
@@ -46,7 +46,7 @@ import * as readline from 'readline';
 /**
  * Current build version from package.json
  */
-const BUILD_VERSION = "0.19.0";
+const BUILD_VERSION = "0.20.0";
 
 const isInteractive = (config) => {
     return config?.mode === 'interactive' || !!config?.interactive;
@@ -6201,1421 +6201,1424 @@ function getPrompt({ template, variables, fallback }) {
     throw new LangChainExecutionError('getPrompt: Unexpected execution path - neither template nor fallback available', { template, fallback, variables });
 }
 
+new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+
 /**
- * Executes a LangChain pipeline with the provided LLM, prompt, variables, and parser.
- * @param params - The execution parameters
- * @returns The parsed result from the LLM chain
- * @throws LangChainExecutionError if the chain execution fails or returns empty results
+ * Base interface that all chains must implement.
  */
-const executeChain = async ({ llm, prompt, variables, parser }) => {
-    validateRequired(llm, 'llm', 'executeChain');
-    validateRequired(prompt, 'prompt', 'executeChain');
-    validateRequired(variables, 'variables', 'executeChain');
-    validateRequired(parser, 'parser', 'executeChain');
-    // Validate that variables is an object
-    if (typeof variables !== 'object' || Array.isArray(variables)) {
-        throw new LangChainExecutionError('executeChain: Variables must be a non-array object', { variables, type: typeof variables, isArray: Array.isArray(variables) });
+class BaseChain extends BaseLangChain {
+    get lc_namespace() {
+        return ["langchain", "chains", this._chainType()];
     }
-    try {
-        const chain = prompt.pipe(llm).pipe(parser);
-        const result = await chain.invoke(variables);
-        if (result === null || result === undefined) {
-            throw new LangChainExecutionError('executeChain: Chain execution returned null or undefined result', { variables, promptInputVariables: prompt.inputVariables });
+    constructor(fields, 
+    /** @deprecated */
+    verbose, 
+    /** @deprecated */
+    callbacks) {
+        if (arguments.length === 1 &&
+            typeof fields === "object" &&
+            !("saveContext" in fields)) {
+            // fields is not a BaseMemory
+            const { memory, callbackManager, ...rest } = fields;
+            super({ ...rest, callbacks: callbackManager ?? rest.callbacks });
+            this.memory = memory;
+        }
+        else {
+            // fields is a BaseMemory
+            super({ verbose, callbacks });
+            this.memory = fields;
         }
-        return result;
     }
-    catch (error) {
-        // Re-throw LangChain errors as-is
-        if (error instanceof LangChainExecutionError) {
-            throw error;
+    /** @ignore */
+    _selectMemoryInputs(values) {
+        const valuesForMemory = { ...values };
+        if ("signal" in valuesForMemory) {
+            delete valuesForMemory.signal;
         }
-        // Wrap other errors with context
-        handleLangChainError(error, 'executeChain: Chain execution failed', {
-            promptInputVariables: prompt.inputVariables,
-            variableKeys: Object.keys(variables),
-            parserType: parser.constructor.name
+        if ("timeout" in valuesForMemory) {
+            delete valuesForMemory.timeout;
+        }
+        return valuesForMemory;
+    }
+    /**
+     * Invoke the chain with the provided input and returns the output.
+     * @param input Input values for the chain run.
+     * @param config Optional configuration for the Runnable.
+     * @returns Promise that resolves with the output of the chain run.
+     */
+    async invoke(input, options) {
+        const config = ensureConfig(options);
+        const fullValues = await this._formatValues(input);
+        const callbackManager_ = await CallbackManager.configure(config?.callbacks, this.callbacks, config?.tags, this.tags, config?.metadata, this.metadata, { verbose: this.verbose });
+        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), fullValues, undefined, undefined, undefined, undefined, config?.runName);
+        let outputValues;
+        try {
+            outputValues = await (fullValues.signal
+                ? Promise.race([
+                    this._call(fullValues, runManager, config),
+                    new Promise((_, reject) => {
+                        fullValues.signal?.addEventListener("abort", () => {
+                            reject(new Error("AbortError"));
+                        });
+                    }),
+                ])
+                : this._call(fullValues, runManager, config));
+        }
+        catch (e) {
+            await runManager?.handleChainError(e);
+            throw e;
+        }
+        if (!(this.memory == null)) {
+            await this.memory.saveContext(this._selectMemoryInputs(input), outputValues);
+        }
+        await runManager?.handleChainEnd(outputValues);
+        // add the runManager's currentRunId to the outputValues
+        Object.defineProperty(outputValues, RUN_KEY, {
+            value: runManager ? { runId: runManager?.runId } : undefined,
+            configurable: true,
         });
+        return outputValues;
     }
-};
-
-function extractTicketIdFromBranchName(branchName) {
-    const regex = /((?<!([A-Z]+)-?)[A-Z]+-\d+)/;
-    const match = branchName.match(regex);
-    return match ? match[0] : null;
-}
-
-/**
- * Formats a commit log into a readable string format.
- *
- * @param commitLog - The commit log result containing an array of commit details.
- * @returns An array of formatted commit log strings.
- *
- * Each formatted string includes:
- * - The date of the commit in square brackets.
- * - The commit message.
- * - The commit body.
- * - The commit hash in parentheses.
- * - The author's name and email in angle brackets.
- */
-const formatCommitLog = (commitLog) => {
-    return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
-};
-
-const getChangesSinceLastTag = async ({ git }) => {
-    const tags = await git.tags();
-    if (tags.all.length > 0) {
-        const lastTag = tags.latest;
-        const commitLog = await git.log({ from: lastTag });
-        return formatCommitLog(commitLog);
+    _validateOutputs(outputs) {
+        const missingKeys = this.outputKeys.filter((k) => !(k in outputs));
+        if (missingKeys.length) {
+            throw new Error(`Missing output keys: ${missingKeys.join(", ")} from chain ${this._chainType()}`);
+        }
     }
-    else {
-        return ['No tags found in the repository.'];
+    async prepOutputs(inputs, outputs, returnOnlyOutputs = false) {
+        this._validateOutputs(outputs);
+        if (this.memory) {
+            await this.memory.saveContext(inputs, outputs);
+        }
+        if (returnOnlyOutputs) {
+            return outputs;
+        }
+        return { ...inputs, ...outputs };
     }
-};
-
-/**
- * Retrieves the commit log range between two specified commits (inclusive of both commits).
- *
- * @param from - The starting commit (can be a commit hash, HEAD reference, or branch name). This commit will be included in the results.
- * @param to - The ending commit (can be a commit hash, HEAD reference, or branch name). This commit will be included in the results.
- * @param options - Additional options for retrieving the commit log range.
- * @returns A promise that resolves to an array of commit log messages, including both the 'from' and 'to' commits.
- * @throws If there is an error retrieving the commit log range.
- */
-async function getCommitLogRange(from, to, { noMerges, git }) {
-    try {
-        // Use from^..to to include the 'from' commit in the range
-        // This works because from^..to means "commits reachable from 'to' but not from the parent of 'from'"
-        const logOptions = {
-            from: `${from}^`,
-            to,
-            '--no-merges': noMerges
-        };
-        const commitLog = await git.log(logOptions);
-        return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
+    /**
+     * Return a json-like object representing this chain.
+     */
+    serialize() {
+        throw new Error("Method not implemented.");
     }
-    catch (error) {
-        // If from^ fails (e.g., 'from' is the first commit), fall back to using from..to and manually adding the 'from' commit
-        if (error instanceof Error && error.message.includes('unknown revision')) {
-            try {
-                // Get the 'from' commit separately
-                const fromCommitLog = await git.log({ from: from, maxCount: 1 });
-                const fromCommit = fromCommitLog.latest;
-                // Get the range from..to (excluding 'from')
-                const rangeLogOptions = {
-                    from,
-                    to,
-                    '--no-merges': noMerges
-                };
-                const rangeCommitLog = await git.log(rangeLogOptions);
-                // Combine the 'from' commit with the range commits
-                const allCommits = fromCommit
-                    ? [fromCommit, ...rangeCommitLog.all]
-                    : rangeCommitLog.all;
-                return allCommits.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
-            }
-            catch (fallbackError) {
-                throw fallbackError;
-            }
+    /** @deprecated Use .invoke() instead. Will be removed in 0.2.0. */
+    async run(
+    // eslint-disable-next-line @typescript-eslint/no-explicit-any
+    input, config) {
+        const inputKeys = this.inputKeys.filter((k) => !this.memory?.memoryKeys.includes(k) ?? true);
+        const isKeylessInput = inputKeys.length <= 1;
+        if (!isKeylessInput) {
+            throw new Error(`Chain ${this._chainType()} expects multiple inputs, cannot use 'run' `);
         }
-        throw error;
-    }
-}
-
-/**
- * Retrieves the name of the current branch.
- *
- * @param {GetCurrentBranchName} options - The options for retrieving the branch name.
- * @returns {Promise<string>} - A promise that resolves to the name of the current branch.
- */
-async function getCurrentBranchName({ git }) {
-    return await git.revparse(['--abbrev-ref', 'HEAD']);
-}
-
-/**
- * Retrieves the commit log between the current branch and a specified target branch.
- *
- * @param {Object} options - The options for retrieving the commit log.
- * @param {SimpleGit} options.git - The SimpleGit instance.
- * @param {Logger} options.logger - The logger for logging messages.
- * @param {string} options.targetBranch - The target branch to compare against.
- * @returns {Promise<string[]>} The array of commit messages in the commit log.
- */
-async function getCommitLogAgainstBranch({ git, logger, targetBranch, }) {
-    try {
-        // Get the current branch name
-        const currentBranch = await getCurrentBranchName({ git });
-        // Get the list of commits that are unique to the current branch compared to the target branch
-        const uniqueCommits = (await git.raw(['rev-list', `${targetBranch}..${currentBranch}`]))
-            .split('\n')
-            .filter(Boolean)
-            .reverse();
-        logger?.verbose(`Found ${uniqueCommits.length} unique commits between "${currentBranch}" and "${targetBranch}"`, { color: 'blue' });
-        const firstCommit = uniqueCommits[0];
-        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
-        if (!firstCommit || !lastCommit) {
-            logger?.log('Unable to determine first and last commit between branches', { color: 'yellow' });
-            return [];
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const values = inputKeys.length ? { [inputKeys[0]]: input } : {};
+        const returnValues = await this.call(values, config);
+        const keys = Object.keys(returnValues);
+        if (keys.length === 1) {
+            return returnValues[keys[0]];
         }
-        // Retrieve commit log with messages
-        return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
-    }
-    catch (error) {
-        logger?.log('Encountered an error getting commit log between branches', { color: 'red' });
+        throw new Error("return values have multiple keys, `run` only supported when one key currently");
     }
-    return [];
-}
-
-/**
- * Retrieves the commit log for the current branch.
- *
- * @param {Object} options - The options for retrieving the commit log.
- * @param {SimpleGit} options.git - The SimpleGit instance.
- * @param {Logger} options.logger - The logger for logging messages.
- * @param {string} [options.comparisonBranch='main'] - The branch to compare against.
- * @param {string} [options.comparisonRemote='origin'] - The remote to compare against.
- * @returns {Promise<string[]>} The array of commit messages in the commit log.
- */
-async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main', comparisonRemote = 'origin', }) {
-    try {
-        const branchName = await getCurrentBranchName({ git });
-        const hasCommits = (await git.raw(['rev-list', '--count', branchName])) !== '0';
-        if (!hasCommits) {
-            logger?.log('No commits on the current branch.');
-            return [];
-        }
-        let uniqueCommits;
-        if (comparisonBranch === branchName) {
-            // If the comparison branch is the same as the current branch, we compare against the remote.
-            uniqueCommits = (await git.raw(['rev-list', `${comparisonRemote}/${comparisonBranch}..${branchName}`]))
-                .split('\n')
-                .filter(Boolean)
-                .reverse();
-        }
-        else {
-            // Your existing code for different branches
-            uniqueCommits = (await git.raw(['rev-list', `${comparisonBranch}..${branchName}`]))
-                .split('\n')
-                .filter(Boolean)
-                .reverse();
+    async _formatValues(values) {
+        const fullValues = { ...values };
+        if (fullValues.timeout && !fullValues.signal) {
+            fullValues.signal = AbortSignal.timeout(fullValues.timeout);
+            delete fullValues.timeout;
         }
-        logger?.verbose(`Found ${uniqueCommits.length} unique commits on "${branchName}"`, {
-            color: 'blue',
-        });
-        const firstCommit = uniqueCommits[0];
-        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
-        if (!firstCommit || !lastCommit) {
-            logger?.log('Unable to determine first and last commit on the current branch', {
-                color: 'yellow',
-            });
-            return [];
+        if (!(this.memory == null)) {
+            const newValues = await this.memory.loadMemoryVariables(this._selectMemoryInputs(values));
+            for (const [key, value] of Object.entries(newValues)) {
+                fullValues[key] = value;
+            }
         }
-        return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
+        return fullValues;
     }
-    catch (error) {
-        logger?.log('Encountered an error getting commit log from current branch', { color: 'red' });
+    /**
+     * @deprecated Use .invoke() instead. Will be removed in 0.2.0.
+     *
+     * Run the core logic of this chain and add to output if desired.
+     *
+     * Wraps _call and handles memory.
+     */
+    async call(values, config, 
+    /** @deprecated */
+    tags) {
+        const parsedConfig = { tags, ...parseCallbackConfigArg(config) };
+        return this.invoke(values, parsedConfig);
+    }
+    /**
+     * @deprecated Use .batch() instead. Will be removed in 0.2.0.
+     *
+     * Call the chain on all inputs in the list
+     */
+    async apply(inputs, config) {
+        return Promise.all(inputs.map(async (i, idx) => this.call(i, config?.[idx])));
+    }
+    /**
+     * Load a chain from a json-like object describing it.
+     */
+    static async deserialize(data, values = {}) {
+        switch (data._type) {
+            case "llm_chain": {
+                const { LLMChain } = await Promise.resolve().then(function () { return llm_chain; });
+                return LLMChain.deserialize(data);
+            }
+            case "sequential_chain": {
+                const { SequentialChain } = await Promise.resolve().then(function () { return sequential_chain; });
+                return SequentialChain.deserialize(data);
+            }
+            case "simple_sequential_chain": {
+                const { SimpleSequentialChain } = await Promise.resolve().then(function () { return sequential_chain; });
+                return SimpleSequentialChain.deserialize(data);
+            }
+            case "stuff_documents_chain": {
+                const { StuffDocumentsChain } = await Promise.resolve().then(function () { return combine_docs_chain; });
+                return StuffDocumentsChain.deserialize(data);
+            }
+            case "map_reduce_documents_chain": {
+                const { MapReduceDocumentsChain } = await Promise.resolve().then(function () { return combine_docs_chain; });
+                return MapReduceDocumentsChain.deserialize(data);
+            }
+            case "refine_documents_chain": {
+                const { RefineDocumentsChain } = await Promise.resolve().then(function () { return combine_docs_chain; });
+                return RefineDocumentsChain.deserialize(data);
+            }
+            case "vector_db_qa": {
+                const { VectorDBQAChain } = await Promise.resolve().then(function () { return vector_db_qa; });
+                return VectorDBQAChain.deserialize(data, values);
+            }
+            case "api_chain": {
+                const { APIChain } = await Promise.resolve().then(function () { return api_chain; });
+                return APIChain.deserialize(data);
+            }
+            default:
+                throw new Error(`Invalid prompt type in config: ${data._type}`);
+        }
     }
-    return [];
 }
 
 /**
- * Retrieves the SimpleGit instance for the repository.
- * @returns {SimpleGit} The SimpleGit instance.
+ * The NoOpOutputParser class is a type of output parser that does not
+ * perform any operations on the output. It extends the BaseOutputParser
+ * class and is part of the LangChain's output parsers module. This class
+ * is useful in scenarios where the raw output of the Large Language
+ * Models (LLMs) is required.
  */
-const getRepo = () => {
-    let git;
-    try {
-        git = simpleGit();
+class NoOpOutputParser extends BaseOutputParser {
+    constructor() {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "default"]
+        });
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
     }
-    catch (e) {
-        console.log('Error initializing git repo', e);
-        process.exit(1);
+    static lc_name() {
+        return "NoOpOutputParser";
     }
-    return git;
-};
+    /**
+     * This method takes a string as input and returns the same string as
+     * output. It does not perform any operations on the input string.
+     * @param text The input string to be parsed.
+     * @returns The same input string without any operations performed on it.
+     */
+    parse(text) {
+        return Promise.resolve(text);
+    }
+    /**
+     * This method returns an empty string. It does not provide any formatting
+     * instructions.
+     * @returns An empty string, indicating no formatting instructions.
+     */
+    getFormatInstructions() {
+        return "";
+    }
+}
 
+function isBaseLanguageModel(llmLike) {
+    return typeof llmLike._llmType === "function";
+}
+function _getLanguageModel(llmLike) {
+    if (isBaseLanguageModel(llmLike)) {
+        return llmLike;
+    }
+    else if ("bound" in llmLike && Runnable.isRunnable(llmLike.bound)) {
+        return _getLanguageModel(llmLike.bound);
+    }
+    else if ("runnable" in llmLike &&
+        "fallbacks" in llmLike &&
+        Runnable.isRunnable(llmLike.runnable)) {
+        return _getLanguageModel(llmLike.runnable);
+    }
+    else if ("default" in llmLike && Runnable.isRunnable(llmLike.default)) {
+        return _getLanguageModel(llmLike.default);
+    }
+    else {
+        throw new Error("Unable to extract BaseLanguageModel from llmLike object.");
+    }
+}
 /**
- * Template for generating git commit messages based on code changes
+ * @deprecated This class will be removed in 1.0.0. Use the LangChain Expression Language (LCEL) instead.
+ * See the example below for how to use LCEL with the LLMChain class:
  *
- * Variables:
- * - summary: Contains the diff summary of staged changes
- * - format_instructions: Instructions for the output format (JSON with title and body)
- * - additional_context: Optional user-provided context to guide the commit message generation
- * - commit_history: Optional history of previous commits for context
- * - branch_name_context: String containing formatted branch name (or empty if disabled)
+ * Chain to run queries against LLMs.
+ *
+ * @example
+ * ```ts
+ * import { ChatPromptTemplate } from "@langchain/core/prompts";
+ * import { ChatOpenAI } from "@langchain/openai";
+ *
+ * const prompt = ChatPromptTemplate.fromTemplate("Tell me a {adjective} joke");
+ * const llm = new ChatOpenAI();
+ * const chain = prompt.pipe(llm);
+ *
+ * const response = await chain.invoke({ adjective: "funny" });
+ * ```
  */
-const template$4 = `Write informative git commit message, in the imperative, based on the diffs & file changes provided in the "Diff Summary" section.
-Commit Messages must have a short description that is less than 50 characters and a longer detailed summary around 300 characters, the shorter and more concise the better.
-
-Please follow the guidelines below when writing your commit message:
-
-- Write concisely using an informal tone
-- Avoid phrases like "this commit", "this change", "this function", etc. Instead refer to the function, variable, or class by name
-- Avoid referencing specific files names or long paths in the commit message
-- DO NOT include any diffs or file changes in the commit message
-- Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
-
-""""""
-{{summary}}
-""""""
-
-{{branch_name_context}}
-
-{{format_instructions}}
-
-{{commit_history}}
-
-{{additional_context}}
-`;
-// Define the variables that will be passed to the prompt template
-const inputVariables$3 = ['summary', 'format_instructions', 'additional_context', 'commit_history', 'branch_name_context'];
-const COMMIT_PROMPT = new PromptTemplate({
-    template: template$4,
-    inputVariables: inputVariables$3,
-});
-const CONVENTIONAL_TEMPLATE = `Generate a commit message that strictly adheres to the Conventional Commits specification. Follow these rules precisely:
-
-1. Type Selection:
-   - Choose ONE of these types based on the changes:
-     * feat: A new feature
-     * fix: A bug fix
-     * docs: Documentation only changes
-     * style: Changes that don't affect the code's meaning (white-space, formatting, etc)
-     * refactor: Code changes that neither fix a bug nor add a feature
-     * perf: Code changes that improve performance
-     * test: Adding missing tests or correcting existing tests
-     * build: Changes that affect the build system or external dependencies
-     * ci: Changes to CI configuration files and scripts
-     * chore: Other changes that don't modify src or test files
-     * revert: Reverts a previous commit
-
-2. Format Requirements:
-   - Title format: <type>(<optional-scope>): <description>
-   - Title must be 50 characters or less
-   - Description should be in imperative mood (e.g., "add" not "adds/added")
-   - Body MUST be 280 characters or less
-   - Separate body from title with a blank line
-   - Body should explain the motivation for the change and contrast it with previous behavior
-
-3. Scope Guidelines:
-   - If the change affects a specific component/area, include it as a scope
-   - Scope should be a noun in parentheses (e.g., (parser), (ui), (config))
-   - Omit scope if the change is broad or affects multiple areas
-
-Based on the following diff summary, generate a conventional commit message that follows these rules exactly:
-
-""""""
-{{summary}}
-""""""
-
-{{branch_name_context}}
-
-{{format_instructions}}
-
-{{commit_history}}
-
-{{additional_context}}
-
-Remember:
-- Be concise and precise
-- Focus on WHAT and WHY, not HOW
-- Use imperative mood in both title and body
-- Ensure the title alone provides enough context to understand the change`;
-const conventionalInputVariables = [
-    'summary',
-    'additional_context',
-    'commit_history',
-    'format_instructions',
-    'branch_name_context',
-];
-const CONVENTIONAL_COMMIT_PROMPT = new PromptTemplate({
-    template: CONVENTIONAL_TEMPLATE,
-    inputVariables: conventionalInputVariables,
-});
-
-/**
- * Verify template string contains all required input variables
- *
- * @param text template string
- * @param inputVariables template variables
- * @throws Error if validation fails
- */
-function validatePromptTemplate(text, inputVariables) {
-    if (!text || text.trim() === '') {
-        throw new Error('Prompt template cannot be empty');
-    }
-    if (!inputVariables || inputVariables.length === 0) {
-        return; // No variables to validate
-    }
-    // Extract variables from template using regex to find {variable} patterns
-    // This regex matches {variable_name} with no whitespace inside braces
-    // Excludes JSON-like patterns with quotes, colons, or whitespace
-    const templateVariableRegex = /\{([^}\s:"']+)\}/g;
-    const foundVariables = new Set();
-    let match;
-    while ((match = templateVariableRegex.exec(text)) !== null) {
-        foundVariables.add(match[1]);
+class LLMChain extends BaseChain {
+    static lc_name() {
+        return "LLMChain";
     }
-    // Check if all required variables are present in template
-    const missingVariables = inputVariables.filter(variable => !foundVariables.has(variable));
-    if (missingVariables.length > 0) {
-        throw new Error(`Prompt template is missing required variables: ${missingVariables.map(v => `{${v}}`).join(', ')}. ` +
-            `Found variables: ${Array.from(foundVariables).map(v => `{${v}}`).join(', ') || 'none'}`);
+    get inputKeys() {
+        return this.prompt.inputVariables;
     }
-    // Warn about unused variables in template (optional check)
-    const unusedVariables = Array.from(foundVariables).filter(variable => !inputVariables.includes(variable));
-    if (unusedVariables.length > 0) {
-        console.warn(`Prompt template contains undefined variables: ${unusedVariables.map(v => `{${v}}`).join(', ')}`);
+    get outputKeys() {
+        return [this.outputKey];
     }
-}
-
-async function editPrompt(options) {
-    return await editor({
-        message: 'Edit the prompt',
-        default: options.prompt?.length ? options.prompt : COMMIT_PROMPT.template,
-        waitForUseInput: false,
-        postfix: 'Press ENTER to continue',
-        validate: (text) => {
-            try {
-                validatePromptTemplate(text, COMMIT_PROMPT.inputVariables);
-                return true;
-            }
-            catch (error) {
-                return error instanceof Error ? error.message : 'Invalid prompt template';
-            }
-        },
-    });
-}
-
-async function editResult(result, options) {
-    if (options.openInEditor) {
-        return await editor({
-            message: 'Edit the commit message',
-            default: result,
-            waitForUseInput: false,
-            validate: (text) => (text ? true : 'Commit message cannot be empty'),
+    constructor(fields) {
+        super(fields);
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
         });
-    }
-    return result;
-}
-
-async function getUserReviewDecision({ label, descriptions, labels, enableEdit = true, enableRetry = true, enableFullRetry = true, enableModifyPrompt = true, selectLabel, }) {
-    const choices = [
-        {
-            name: labels?.approve || '✨ Looks good!',
-            value: 'approve',
-            description: descriptions?.approve || `Continue with the generated ${label}`,
-        },
-    ];
-    if (enableEdit) {
-        choices.push({
-            name: '📝 Edit',
-            value: 'edit',
-            description: descriptions?.edit || `Edit the generated ${label} before proceeding`,
+        Object.defineProperty(this, "prompt", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
         });
-    }
-    if (enableModifyPrompt) {
-        choices.push({
-            name: '🪶  Modify Prompt',
-            value: 'modifyPrompt',
-            description: descriptions?.modifyPrompt || `Modify the prompt template and regenerate the ${label}`,
+        Object.defineProperty(this, "llm", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
         });
-    }
-    if (enableRetry) {
-        choices.push({
-            name: labels?.retryMessageOnly || '🔄 Retry',
-            value: 'retryMessageOnly',
-            description: descriptions?.retryMessageOnly ||
-                `Restart the function execution from generating the ${label}`,
+        Object.defineProperty(this, "llmKwargs", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
         });
-    }
-    if (enableFullRetry) {
-        choices.push({
-            name: labels?.retryFull || '🔄 Retry Full',
-            value: 'retryFull',
-            description: descriptions?.retryFull ||
-                `Restart the function execution from the beginning, regenerating both the summary and ${label}`,
+        Object.defineProperty(this, "outputKey", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: "text"
         });
+        Object.defineProperty(this, "outputParser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.prompt = fields.prompt;
+        this.llm = fields.llm;
+        this.llmKwargs = fields.llmKwargs;
+        this.outputKey = fields.outputKey ?? this.outputKey;
+        this.outputParser =
+            fields.outputParser ?? new NoOpOutputParser();
+        if (this.prompt.outputParser) {
+            if (fields.outputParser) {
+                throw new Error("Cannot set both outputParser and prompt.outputParser");
+            }
+            this.outputParser = this.prompt.outputParser;
+        }
     }
-    choices.push({
-        name: labels?.cancel || '💣 Cancel',
-        value: 'cancel',
-        description: descriptions?.cancel || `Cancel the ${label}`,
-    });
-    return (await select({
-        message: selectLabel || `Would you like to make any changes to the ${label}?`,
-        choices,
-    }));
-}
-
-function logResult(label, result) {
-    console.log(`\n${chalk.bgBlue(chalk.bold(`Proposed ${label}:`))}\n${SEPERATOR}\n${result}\n${SEPERATOR}\n`);
-}
-
-async function generateAndReviewLoop({ label, factory, parser, noResult, agent, reviewParser, options, }) {
-    const { logger } = options;
-    let continueLoop = true;
-    let modifyPrompt = false;
-    let context = '';
-    let result = '';
-    const changes = await factory();
-    // if we don't have any changes, bail.
-    if (!changes || !Object.keys(changes).length) {
-        await noResult(options);
+    getCallKeys() {
+        const callKeys = "callKeys" in this.llm ? this.llm.callKeys : [];
+        return callKeys;
     }
-    while (continueLoop) {
-        if (!context.length) {
-            context = await parser(changes, result, options);
+    /** @ignore */
+    _selectMemoryInputs(values) {
+        const valuesForMemory = super._selectMemoryInputs(values);
+        const callKeys = this.getCallKeys();
+        for (const key of callKeys) {
+            if (key in values) {
+                delete valuesForMemory[key];
+            }
         }
-        // if we still don't have a context, bail.
-        if (!context.length) {
-            await noResult(options);
+        return valuesForMemory;
+    }
+    /** @ignore */
+    async _getFinalOutput(generations, promptValue, runManager) {
+        let finalCompletion;
+        if (this.outputParser) {
+            finalCompletion = await this.outputParser.parseResultWithPrompt(generations, promptValue, runManager?.getChild());
         }
-        if (modifyPrompt) {
-            options.prompt = await editPrompt(options);
+        else {
+            finalCompletion = generations[0].text;
         }
-        logger.startTimer().startSpinner(`Generating ${label}\n`, {
-            color: 'blue',
-        });
-        try {
-            result = await agent(context, options);
-            if (!result) {
-                logger.stopSpinner('💀 Agent failed to return content.', {
-                    mode: 'fail',
-                    color: 'red',
-                });
-                process.exit(0);
+        return finalCompletion;
+    }
+    /**
+     * Run the core logic of this chain and add to output if desired.
+     *
+     * Wraps _call and handles memory.
+     */
+    call(values, config) {
+        return super.call(values, config);
+    }
+    /** @ignore */
+    async _call(values, runManager) {
+        const valuesForPrompt = { ...values };
+        const valuesForLLM = {
+            ...this.llmKwargs,
+        };
+        const callKeys = this.getCallKeys();
+        for (const key of callKeys) {
+            if (key in values) {
+                if (valuesForLLM) {
+                    valuesForLLM[key] =
+                        values[key];
+                    delete valuesForPrompt[key];
+                }
             }
         }
-        catch (error) {
-            // Handle special regeneration request from validation
-            if (error.message === 'REGENERATE_COMMIT_MESSAGE') {
-                logger.stopSpinner('Regenerating commit message...', {
-                    mode: 'stop',
-                    color: 'blue',
-                });
-                result = '';
-                continue;
-            }
-            // Re-throw other errors
-            throw error;
+        const promptValue = await this.prompt.formatPromptValue(valuesForPrompt);
+        if ("generatePrompt" in this.llm) {
+            const { generations } = await this.llm.generatePrompt([promptValue], valuesForLLM, runManager?.getChild());
+            return {
+                [this.outputKey]: await this._getFinalOutput(generations[0], promptValue, runManager),
+            };
         }
-        logger
-            .stopSpinner(`Generated ${label}`, {
-            color: 'green',
-            mode: 'succeed',
-        })
-            .stopTimer();
-        if (options?.interactive) {
-            logResult(label, reviewParser ? reviewParser(result, options) : result);
-            const reviewAnswer = await getUserReviewDecision({
-                label,
-                ...(options?.review || {}),
-            });
-            if (reviewAnswer === 'cancel') {
-                process.exit(0);
-            }
-            if (reviewAnswer === 'edit') {
-                options.openInEditor = true;
-            }
-            if (reviewAnswer === 'retryFull') {
-                context = '';
-                result = '';
-                options.prompt = '';
-                continue;
-            }
-            if (reviewAnswer === 'retryMessageOnly') {
-                modifyPrompt = false;
-                result = '';
-                continue;
-            }
-            if (reviewAnswer === 'modifyPrompt') {
-                modifyPrompt = true;
-                result = '';
-                continue;
-            }
-            // Only edit the result in interactive mode if approved
-            result = await editResult(result, options);
+        const modelWithParser = this.outputParser
+            ? this.llm.pipe(this.outputParser)
+            : this.llm;
+        const response = await modelWithParser.invoke(promptValue, runManager?.getChild());
+        return {
+            [this.outputKey]: response,
+        };
+    }
+    /**
+     * Format prompt with values and pass to LLM
+     *
+     * @param values - keys to pass to prompt template
+     * @param callbackManager - CallbackManager to use
+     * @returns Completion from LLM.
+     *
+     * @example
+     * ```ts
+     * llm.predict({ adjective: "funny" })
+     * ```
+     */
+    async predict(values, callbackManager) {
+        const output = await this.call(values, callbackManager);
+        return output[this.outputKey];
+    }
+    _chainType() {
+        return "llm";
+    }
+    static async deserialize(data) {
+        const { llm, prompt } = data;
+        if (!llm) {
+            throw new Error("LLMChain must have llm");
         }
-        else {
-            // In non-interactive mode, we return the result as is to be output to stdout by the caller.
-            const displayResult = reviewParser ? reviewParser(result, options) : result;
-            // In non-interactive mode, ensure we return the properly formatted result
-            result = displayResult;
+        if (!prompt) {
+            throw new Error("LLMChain must have prompt");
         }
-        // if we're here, we're done.
-        continueLoop = false;
+        return new LLMChain({
+            llm: await BaseLanguageModel.deserialize(llm),
+            prompt: await BasePromptTemplate.deserialize(prompt),
+        });
     }
-    return result;
-}
-
-const logSuccess = () => {
-    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
-};
-
-async function handleResult({ result, mode, interactiveModeCallback }) {
-    switch (mode) {
-        case 'interactive':
-            if (interactiveModeCallback) {
-                await interactiveModeCallback(result);
-            }
-            else {
-                console.warn('No result handler provided for interactive mode.');
-                logSuccess();
-            }
-            break;
-        case 'stdout':
-        default:
-            // Ensure we write the result to stdout in non-interactive mode
-            process.stdout.write(result + '\n', 'utf8');
-            break;
+    /** @deprecated */
+    serialize() {
+        const serialize = "serialize" in this.llm ? this.llm.serialize() : undefined;
+        return {
+            _type: `${this._chainType()}_chain`,
+            llm: serialize,
+            prompt: this.prompt.serialize(),
+        };
+    }
+    _getNumTokens(text) {
+        return _getLanguageModel(this.llm).getNumTokens(text);
     }
-    process.exit(0);
 }
 
-const template$3 = `Write informative git changelog, in the imperative, based on a series of individual messages.
+var llm_chain = /*#__PURE__*/Object.freeze({
+  __proto__: null,
+  LLMChain: LLMChain
+});
 
-- Annotate  each change with the git commit hash as reference, including just the first 7 characters
-- Logically group changes, and if necessary, summarize dependency updates
-- Include a descriptive title for the changelog, to give a high-level overview of the changes
-- Depending on the size of the changes, consider breaking the changelog into sections
-- Avoid generlizations like "various bug fixes" or "improvements" or "enhancements"
+const NAIVE_FIX_TEMPLATE = `Instructions:
+--------------
+{instructions}
+--------------
+Completion:
+--------------
+{completion}
+--------------
 
-{{format_instructions}}
+Above, the Completion did not satisfy the constraints given in the Instructions.
+Error:
+--------------
+{error}
+--------------
 
-"""{{summary}}"""`;
-const inputVariables$2 = ['format_instructions', 'summary'];
-const CHANGELOG_PROMPT = new PromptTemplate({
-    template: template$3,
-    inputVariables: inputVariables$2,
-});
+Please try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:`;
+const NAIVE_FIX_PROMPT = 
+/* #__PURE__ */ PromptTemplate.fromTemplate(NAIVE_FIX_TEMPLATE);
 
-const handler$4 = async (argv, logger) => {
-    const config = loadConfig(argv);
-    const git = getRepo();
-    const key = getApiKeyForModel(config);
-    const { provider, model } = getModelAndProviderFromConfig(config);
-    if (config.service.authentication.type !== 'None' && !key) {
-        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
-        process.exit(1);
+function isLLMChain(x) {
+    return (x.prompt !== undefined && x.llm !== undefined);
+}
+/**
+ * Class that extends the BaseOutputParser to handle situations where the
+ * initial parsing attempt fails. It contains a retryChain for retrying
+ * the parsing process in case of a failure.
+ */
+class OutputFixingParser extends BaseOutputParser {
+    static lc_name() {
+        return "OutputFixingParser";
     }
-    const llm = getLlm(provider, model, config);
-    const INTERACTIVE = isInteractive(config);
-    if (INTERACTIVE) {
-        if (!config.hideCocoBanner) {
-            logger.log(LOGO);
-        }
+    /**
+     * Static method to create a new instance of OutputFixingParser using a
+     * given language model, parser, and optional fields.
+     * @param llm The language model to be used.
+     * @param parser The parser to be used.
+     * @param fields Optional fields which may contain a prompt.
+     * @returns A new instance of OutputFixingParser.
+     */
+    static fromLLM(llm, parser, fields) {
+        const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;
+        const chain = new LLMChain({ llm, prompt });
+        return new OutputFixingParser({ parser, retryChain: chain });
     }
-    async function factory() {
-        const branchName = await getCurrentBranchName({ git });
-        if (config.sinceLastTag) {
-            logger.verbose(`Generating commit log since the last tag`, { color: 'yellow' });
-            return {
-                branch: branchName,
-                commits: await getChangesSinceLastTag({ git, logger }),
-            };
-        }
-        if (config.range && config.range.includes(':')) {
-            const [from, to] = config.range.split(':');
-            if (!from || !to) {
-                logger.log(`Invalid range provided. Expected format is <from>:<to>`, { color: 'red' });
-                process.exit(1);
-            }
-            return {
-                branch: branchName,
-                commits: await getCommitLogRange(from, to, { git, noMerges: true }),
-            };
-        }
-        if (argv.branch) {
-            logger.verbose(`Generating commit log against branch: ${argv.branch}`, { color: 'yellow' });
-            return {
-                branch: branchName,
-                commits: await getCommitLogAgainstBranch({ git, logger, targetBranch: argv.branch }),
-            };
-        }
-        logger.verbose(`No range, branch, or tag option provided. Defaulting to current branch`, {
-            color: 'yellow',
+    constructor({ parser, retryChain, }) {
+        super(...arguments);
+        Object.defineProperty(this, "lc_namespace", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: ["langchain", "output_parsers", "fix"]
         });
-        const commits = await getCommitLogCurrentBranch({ git, logger });
-        return {
-            branch: branchName,
-            commits,
-        };
+        Object.defineProperty(this, "lc_serializable", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: true
+        });
+        Object.defineProperty(this, "parser", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        Object.defineProperty(this, "retryChain", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.parser = parser;
+        this.retryChain = retryChain;
     }
-    async function parser({ branch, commits }) {
-        let result;
-        if (!commits || commits.length === 0) {
-            result = `## ${branch}\n\nNo commits found.`;
+    /**
+     * Method to parse the completion using the parser. If the initial parsing
+     * fails, it uses the retryChain to attempt to fix the output and retry
+     * the parsing process.
+     * @param completion The completion to be parsed.
+     * @param callbacks Optional callbacks to be used during parsing.
+     * @returns The parsed output.
+     */
+    async parse(completion, callbacks) {
+        try {
+            return await this.parser.parse(completion, callbacks);
         }
-        else {
-            result = `## ${branch}\n\n${commits.map((commit) => commit.trim()).join('\n\n')}`;
+        catch (e) {
+            // eslint-disable-next-line no-instanceof/no-instanceof
+            if (e instanceof OutputParserException) {
+                const retryInput = {
+                    instructions: this.parser.getFormatInstructions(),
+                    completion,
+                    error: e,
+                };
+                if (isLLMChain(this.retryChain)) {
+                    const result = await this.retryChain.call(retryInput, callbacks);
+                    const newCompletion = result[this.retryChain.outputKey];
+                    return this.parser.parse(newCompletion, callbacks);
+                }
+                else {
+                    const result = await this.retryChain.invoke(retryInput, {
+                        callbacks,
+                    });
+                    return result;
+                }
+            }
+            throw e;
+        }
+    }
+    /**
+     * Method to get the format instructions for the parser.
+     * @returns The format instructions for the parser.
+     */
+    getFormatInstructions() {
+        return this.parser.getFormatInstructions();
+    }
+}
+
+/**
+ * Creates a parser with built-in retry logic for schema-based generation
+ * @param schema - Zod schema for the expected output structure
+ * @param llm - LLM instance for retry attempts
+ * @param options - Configuration options for retry behavior
+ * @returns OutputFixingParser configured with retry logic
+ * @throws LangChainExecutionError if parser creation fails
+ */
+function createSchemaParser(schema, llm, options = {}) {
+    validateRequired(schema, 'schema', 'createSchemaParser');
+    validateRequired(llm, 'llm', 'createSchemaParser');
+    validateRequired(options, 'options', 'createSchemaParser');
+    // Validate schema is actually a Zod schema
+    if (typeof schema.parse !== 'function') {
+        throw new LangChainExecutionError('createSchemaParser: Schema must be a valid Zod schema with a parse method', { schemaType: typeof schema, hasParseMethod: typeof schema.parse });
+    }
+    // Validate options structure
+    if (typeof options !== 'object' || Array.isArray(options)) {
+        throw new LangChainExecutionError('createSchemaParser: Options must be a non-array object', { options, type: typeof options, isArray: Array.isArray(options) });
+    }
+    const { retryTemplate } = options;
+    // Validate retryTemplate if provided
+    if (retryTemplate !== undefined && typeof retryTemplate !== 'string') {
+        throw new LangChainExecutionError('createSchemaParser: retryTemplate must be a string when provided', { retryTemplate, type: typeof retryTemplate });
+    }
+    try {
+        // @ts-expect-error - StructuredOutputParser constructor type issue with Zod schema
+        const baseParser = new StructuredOutputParser(schema);
+        const defaultRetryTemplate = `The following text failed to parse as valid JSON. Please convert it into a valid JSON object that matches the required schema.
+
+## Text to fix:
+{completion}
+
+## Instructions: 
+{instructions}
+
+You must return ONLY valid JSON that matches the schema exactly. Do not include any additional text, explanations, or markdown formatting:`;
+        const retryPromptTemplate = new PromptTemplate({
+            template: retryTemplate || defaultRetryTemplate,
+            inputVariables: ['completion', 'instructions'],
+        });
+        const retryChain = retryPromptTemplate.pipe(llm).pipe(baseParser);
+        return new OutputFixingParser({
+            parser: baseParser,
+            retryChain: retryChain,
+        });
+    }
+    catch (error) {
+        handleLangChainError(error, 'createSchemaParser: Failed to create schema parser', {
+            schemaName: schema.constructor.name,
+            llmType: llm.constructor.name,
+            hasRetryTemplate: !!retryTemplate
+        });
+    }
+}
+
+/**
+ * Executes a LangChain pipeline with the provided LLM, prompt, variables, and parser.
+ * @param params - The execution parameters
+ * @returns The parsed result from the LLM chain
+ * @throws LangChainExecutionError if the chain execution fails or returns empty results
+ */
+const executeChain = async ({ llm, prompt, variables, parser }) => {
+    validateRequired(llm, 'llm', 'executeChain');
+    validateRequired(prompt, 'prompt', 'executeChain');
+    validateRequired(variables, 'variables', 'executeChain');
+    validateRequired(parser, 'parser', 'executeChain');
+    // Validate that variables is an object
+    if (typeof variables !== 'object' || Array.isArray(variables)) {
+        throw new LangChainExecutionError('executeChain: Variables must be a non-array object', { variables, type: typeof variables, isArray: Array.isArray(variables) });
+    }
+    try {
+        const chain = prompt.pipe(llm).pipe(parser);
+        const result = await chain.invoke(variables);
+        if (result === null || result === undefined) {
+            throw new LangChainExecutionError('executeChain: Chain execution returned null or undefined result', { variables, promptInputVariables: prompt.inputVariables });
         }
         return result;
     }
-    const changelogMsg = await generateAndReviewLoop({
-        label: 'changelog',
-        options: {
-            ...config,
-            prompt: config.prompt || CHANGELOG_PROMPT.template,
-            logger,
-            interactive: INTERACTIVE,
-            review: {
-                enableFullRetry: false,
-            },
-        },
-        factory,
-        parser,
-        agent: async (context, options) => {
-            const parser = new StructuredOutputParser(ChangelogResponseSchema);
-            const prompt = getPrompt({
-                template: options.prompt,
-                variables: CHANGELOG_PROMPT.inputVariables,
-                fallback: CHANGELOG_PROMPT,
-            });
-            const formatInstructions = "Only respond with a valid JSON object, containing two fields: 'title' an escaped string, no more than 65 characters, and 'content' also an escaped string.";
-            const changelog = await executeChain({
-                llm,
-                prompt,
-                variables: {
-                    summary: context,
-                    format_instructions: formatInstructions,
-                },
-                parser,
-            });
-            const branchName = await getCurrentBranchName({ git });
-            const ticketId = extractTicketIdFromBranchName(branchName);
-            const footer = ticketId ? `\n\nPart of **${ticketId}**` : '';
-            return `${changelog.title}\n\n${changelog.content}${footer}`;
-        },
-        noResult: async () => {
-            if (config.range) {
-                logger.log(`No commits found in the provided range.`, { color: 'red' });
-                process.exit(0);
-            }
-            logger.log(`No commits found in the current branch.`, { color: 'red' });
-            process.exit(0);
-        },
-    });
-    const MODE = (INTERACTIVE && 'interactive') || (config.commit && 'interactive') || config?.mode || 'stdout';
-    handleResult({
-        result: changelogMsg,
-        interactiveModeCallback: async () => {
-            logSuccess();
-        },
-        mode: MODE,
-    });
+    catch (error) {
+        // Re-throw LangChain errors as-is
+        if (error instanceof LangChainExecutionError) {
+            throw error;
+        }
+        // Wrap other errors with context
+        handleLangChainError(error, 'executeChain: Chain execution failed', {
+            promptInputVariables: prompt.inputVariables,
+            variableKeys: Object.keys(variables),
+            parserType: parser.constructor.name
+        });
+    }
 };
 
-var changelog = {
-    command: command$4,
-    desc: 'Generate a changelog from current or target branch, provided commit range, or since the last tag.',
-    builder: builder$4,
-    handler: commandExecutor(handler$4),
-    options: options$4,
-};
+function extractTicketIdFromBranchName(branchName) {
+    const regex = /((?<!([A-Z]+)-?)[A-Z]+-\d+)/;
+    const match = branchName.match(regex);
+    return match ? match[0] : null;
+}
 
-const conventionalTypeRegex = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?:/;
-// Regular commit message schema with basic validation
-const CommitMessageResponseSchema = objectType({
-    title: stringType(),
-    body: stringType(),
-});
-// Conventional commit message schema with strict formatting rules
-const ConventionalCommitMessageResponseSchema = objectType({
-    title: stringType()
-        .max(50, "Title must be 50 characters or less")
-        .refine((title) => conventionalTypeRegex.test(title), "Title must follow Conventional Commits format (e.g., 'feat: add new feature' or 'fix(scope): fix bug')"),
-    body: stringType()
-    // .max(280, "Body must be 280 characters or less"),
-});
-const command$3 = 'commit';
 /**
- * Command line options via yargs
+ * Formats a commit log into a readable string format.
+ *
+ * @param commitLog - The commit log result containing an array of commit details.
+ * @returns An array of formatted commit log strings.
+ *
+ * Each formatted string includes:
+ * - The date of the commit in square brackets.
+ * - The commit message.
+ * - The commit body.
+ * - The commit hash in parentheses.
+ * - The author's name and email in angle brackets.
  */
-const options$3 = {
-    i: {
-        alias: 'interactive',
-        description: 'Toggle interactive mode',
-        type: 'boolean',
-    },
-    ignoredFiles: {
-        description: 'Ignored files',
-        type: 'array',
-    },
-    ignoredExtensions: {
-        description: 'Ignored extensions',
-        type: 'array',
-    },
-    append: {
-        description: 'Add content to the end of the generated commit message',
-        type: 'string',
-    },
-    appendTicket: {
-        description: 'Append ticket ID from branch name to the commit message',
-        type: 'boolean',
-        alias: 't',
-    },
-    additional: {
-        description: 'Add extra contextual information to the prompt',
-        type: 'string',
-        alias: 'a',
-    },
-    withPreviousCommits: {
-        description: 'Include previous commits as context (specify number of commits, 0 for none)',
-        type: 'number',
-        default: 0,
-        alias: 'p',
-    },
-    conventional: {
-        description: 'Generate commit message in Conventional Commits format',
-        type: 'boolean',
-        default: false,
-        alias: 'c',
-    },
-    includeBranchName: {
-        description: 'Include the current branch name in the commit prompt for context',
-        type: 'boolean',
-        default: true,
-    },
-    noDiff: {
-        description: 'Only pass basic "git status" result instead of providing entire diff',
-        type: 'boolean',
-        default: false,
-    },
+const formatCommitLog = (commitLog) => {
+    return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
 };
-const builder$3 = (yargs) => {
-    return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
+
+const getChangesSinceLastTag = async ({ git }) => {
+    const tags = await git.tags();
+    if (tags.all.length > 0) {
+        const lastTag = tags.latest;
+        const commitLog = await git.log({ from: lastTag });
+        return formatCommitLog(commitLog);
+    }
+    else {
+        return ['No tags found in the repository.'];
+    }
 };
 
-new Set("ABCDEFGHIJKLMNOPQRSTUVXYZabcdefghijklmnopqrstuvxyz0123456789");
+/**
+ * Retrieves the commit log range between two specified commits (inclusive of both commits).
+ *
+ * @param from - The starting commit (can be a commit hash, HEAD reference, or branch name). This commit will be included in the results.
+ * @param to - The ending commit (can be a commit hash, HEAD reference, or branch name). This commit will be included in the results.
+ * @param options - Additional options for retrieving the commit log range.
+ * @returns A promise that resolves to an array of commit log messages, including both the 'from' and 'to' commits.
+ * @throws If there is an error retrieving the commit log range.
+ */
+async function getCommitLogRange(from, to, { noMerges, git }) {
+    try {
+        // Use from^..to to include the 'from' commit in the range
+        // This works because from^..to means "commits reachable from 'to' but not from the parent of 'from'"
+        const logOptions = {
+            from: `${from}^`,
+            to,
+            '--no-merges': noMerges
+        };
+        const commitLog = await git.log(logOptions);
+        return commitLog.all.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
+    }
+    catch (error) {
+        // If from^ fails (e.g., 'from' is the first commit), fall back to using from..to and manually adding the 'from' commit
+        if (error instanceof Error && error.message.includes('unknown revision')) {
+            try {
+                // Get the 'from' commit separately
+                const fromCommitLog = await git.log({ from: from, maxCount: 1 });
+                const fromCommit = fromCommitLog.latest;
+                // Get the range from..to (excluding 'from')
+                const rangeLogOptions = {
+                    from,
+                    to,
+                    '--no-merges': noMerges
+                };
+                const rangeCommitLog = await git.log(rangeLogOptions);
+                // Combine the 'from' commit with the range commits
+                const allCommits = fromCommit
+                    ? [fromCommit, ...rangeCommitLog.all]
+                    : rangeCommitLog.all;
+                return allCommits.map(({ message, date, body, author_name, hash, author_email }) => `[${date}] ${message}\n${body}\n(${hash}) - ${author_name}<${author_email}>`);
+            }
+            catch (fallbackError) {
+                throw fallbackError;
+            }
+        }
+        throw error;
+    }
+}
+
+/**
+ * Retrieves the name of the current branch.
+ *
+ * @param {GetCurrentBranchName} options - The options for retrieving the branch name.
+ * @returns {Promise<string>} - A promise that resolves to the name of the current branch.
+ */
+async function getCurrentBranchName({ git }) {
+    return await git.revparse(['--abbrev-ref', 'HEAD']);
+}
 
 /**
- * Base interface that all chains must implement.
+ * Retrieves the commit log between the current branch and a specified target branch.
+ *
+ * @param {Object} options - The options for retrieving the commit log.
+ * @param {SimpleGit} options.git - The SimpleGit instance.
+ * @param {Logger} options.logger - The logger for logging messages.
+ * @param {string} options.targetBranch - The target branch to compare against.
+ * @returns {Promise<string[]>} The array of commit messages in the commit log.
  */
-class BaseChain extends BaseLangChain {
-    get lc_namespace() {
-        return ["langchain", "chains", this._chainType()];
-    }
-    constructor(fields, 
-    /** @deprecated */
-    verbose, 
-    /** @deprecated */
-    callbacks) {
-        if (arguments.length === 1 &&
-            typeof fields === "object" &&
-            !("saveContext" in fields)) {
-            // fields is not a BaseMemory
-            const { memory, callbackManager, ...rest } = fields;
-            super({ ...rest, callbacks: callbackManager ?? rest.callbacks });
-            this.memory = memory;
-        }
-        else {
-            // fields is a BaseMemory
-            super({ verbose, callbacks });
-            this.memory = fields;
+async function getCommitLogAgainstBranch({ git, logger, targetBranch, }) {
+    try {
+        // Get the current branch name
+        const currentBranch = await getCurrentBranchName({ git });
+        // Get the list of commits that are unique to the current branch compared to the target branch
+        const uniqueCommits = (await git.raw(['rev-list', `${targetBranch}..${currentBranch}`]))
+            .split('\n')
+            .filter(Boolean)
+            .reverse();
+        logger?.verbose(`Found ${uniqueCommits.length} unique commits between "${currentBranch}" and "${targetBranch}"`, { color: 'blue' });
+        const firstCommit = uniqueCommits[0];
+        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
+        if (!firstCommit || !lastCommit) {
+            logger?.log('Unable to determine first and last commit between branches', { color: 'yellow' });
+            return [];
         }
+        // Retrieve commit log with messages
+        return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
     }
-    /** @ignore */
-    _selectMemoryInputs(values) {
-        const valuesForMemory = { ...values };
-        if ("signal" in valuesForMemory) {
-            delete valuesForMemory.signal;
-        }
-        if ("timeout" in valuesForMemory) {
-            delete valuesForMemory.timeout;
-        }
-        return valuesForMemory;
+    catch (error) {
+        logger?.log('Encountered an error getting commit log between branches', { color: 'red' });
     }
-    /**
-     * Invoke the chain with the provided input and returns the output.
-     * @param input Input values for the chain run.
-     * @param config Optional configuration for the Runnable.
-     * @returns Promise that resolves with the output of the chain run.
-     */
-    async invoke(input, options) {
-        const config = ensureConfig(options);
-        const fullValues = await this._formatValues(input);
-        const callbackManager_ = await CallbackManager.configure(config?.callbacks, this.callbacks, config?.tags, this.tags, config?.metadata, this.metadata, { verbose: this.verbose });
-        const runManager = await callbackManager_?.handleChainStart(this.toJSON(), fullValues, undefined, undefined, undefined, undefined, config?.runName);
-        let outputValues;
-        try {
-            outputValues = await (fullValues.signal
-                ? Promise.race([
-                    this._call(fullValues, runManager, config),
-                    new Promise((_, reject) => {
-                        fullValues.signal?.addEventListener("abort", () => {
-                            reject(new Error("AbortError"));
-                        });
-                    }),
-                ])
-                : this._call(fullValues, runManager, config));
+    return [];
+}
+
+/**
+ * Retrieves the commit log for the current branch.
+ *
+ * @param {Object} options - The options for retrieving the commit log.
+ * @param {SimpleGit} options.git - The SimpleGit instance.
+ * @param {Logger} options.logger - The logger for logging messages.
+ * @param {string} [options.comparisonBranch='main'] - The branch to compare against.
+ * @param {string} [options.comparisonRemote='origin'] - The remote to compare against.
+ * @returns {Promise<string[]>} The array of commit messages in the commit log.
+ */
+async function getCommitLogCurrentBranch({ git, logger, comparisonBranch = 'main', comparisonRemote = 'origin', }) {
+    try {
+        const branchName = await getCurrentBranchName({ git });
+        const hasCommits = (await git.raw(['rev-list', '--count', branchName])) !== '0';
+        if (!hasCommits) {
+            logger?.log('No commits on the current branch.');
+            return [];
         }
-        catch (e) {
-            await runManager?.handleChainError(e);
-            throw e;
+        let uniqueCommits;
+        if (comparisonBranch === branchName) {
+            // If the comparison branch is the same as the current branch, we compare against the remote.
+            uniqueCommits = (await git.raw(['rev-list', `${comparisonRemote}/${comparisonBranch}..${branchName}`]))
+                .split('\n')
+                .filter(Boolean)
+                .reverse();
         }
-        if (!(this.memory == null)) {
-            await this.memory.saveContext(this._selectMemoryInputs(input), outputValues);
+        else {
+            // Your existing code for different branches
+            uniqueCommits = (await git.raw(['rev-list', `${comparisonBranch}..${branchName}`]))
+                .split('\n')
+                .filter(Boolean)
+                .reverse();
         }
-        await runManager?.handleChainEnd(outputValues);
-        // add the runManager's currentRunId to the outputValues
-        Object.defineProperty(outputValues, RUN_KEY, {
-            value: runManager ? { runId: runManager?.runId } : undefined,
-            configurable: true,
+        logger?.verbose(`Found ${uniqueCommits.length} unique commits on "${branchName}"`, {
+            color: 'blue',
         });
-        return outputValues;
-    }
-    _validateOutputs(outputs) {
-        const missingKeys = this.outputKeys.filter((k) => !(k in outputs));
-        if (missingKeys.length) {
-            throw new Error(`Missing output keys: ${missingKeys.join(", ")} from chain ${this._chainType()}`);
-        }
-    }
-    async prepOutputs(inputs, outputs, returnOnlyOutputs = false) {
-        this._validateOutputs(outputs);
-        if (this.memory) {
-            await this.memory.saveContext(inputs, outputs);
-        }
-        if (returnOnlyOutputs) {
-            return outputs;
-        }
-        return { ...inputs, ...outputs };
-    }
-    /**
-     * Return a json-like object representing this chain.
-     */
-    serialize() {
-        throw new Error("Method not implemented.");
-    }
-    /** @deprecated Use .invoke() instead. Will be removed in 0.2.0. */
-    async run(
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    input, config) {
-        const inputKeys = this.inputKeys.filter((k) => !this.memory?.memoryKeys.includes(k) ?? true);
-        const isKeylessInput = inputKeys.length <= 1;
-        if (!isKeylessInput) {
-            throw new Error(`Chain ${this._chainType()} expects multiple inputs, cannot use 'run' `);
-        }
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const values = inputKeys.length ? { [inputKeys[0]]: input } : {};
-        const returnValues = await this.call(values, config);
-        const keys = Object.keys(returnValues);
-        if (keys.length === 1) {
-            return returnValues[keys[0]];
-        }
-        throw new Error("return values have multiple keys, `run` only supported when one key currently");
-    }
-    async _formatValues(values) {
-        const fullValues = { ...values };
-        if (fullValues.timeout && !fullValues.signal) {
-            fullValues.signal = AbortSignal.timeout(fullValues.timeout);
-            delete fullValues.timeout;
-        }
-        if (!(this.memory == null)) {
-            const newValues = await this.memory.loadMemoryVariables(this._selectMemoryInputs(values));
-            for (const [key, value] of Object.entries(newValues)) {
-                fullValues[key] = value;
-            }
-        }
-        return fullValues;
-    }
-    /**
-     * @deprecated Use .invoke() instead. Will be removed in 0.2.0.
-     *
-     * Run the core logic of this chain and add to output if desired.
-     *
-     * Wraps _call and handles memory.
-     */
-    async call(values, config, 
-    /** @deprecated */
-    tags) {
-        const parsedConfig = { tags, ...parseCallbackConfigArg(config) };
-        return this.invoke(values, parsedConfig);
-    }
-    /**
-     * @deprecated Use .batch() instead. Will be removed in 0.2.0.
-     *
-     * Call the chain on all inputs in the list
-     */
-    async apply(inputs, config) {
-        return Promise.all(inputs.map(async (i, idx) => this.call(i, config?.[idx])));
-    }
-    /**
-     * Load a chain from a json-like object describing it.
-     */
-    static async deserialize(data, values = {}) {
-        switch (data._type) {
-            case "llm_chain": {
-                const { LLMChain } = await Promise.resolve().then(function () { return llm_chain; });
-                return LLMChain.deserialize(data);
-            }
-            case "sequential_chain": {
-                const { SequentialChain } = await Promise.resolve().then(function () { return sequential_chain; });
-                return SequentialChain.deserialize(data);
-            }
-            case "simple_sequential_chain": {
-                const { SimpleSequentialChain } = await Promise.resolve().then(function () { return sequential_chain; });
-                return SimpleSequentialChain.deserialize(data);
-            }
-            case "stuff_documents_chain": {
-                const { StuffDocumentsChain } = await Promise.resolve().then(function () { return combine_docs_chain; });
-                return StuffDocumentsChain.deserialize(data);
-            }
-            case "map_reduce_documents_chain": {
-                const { MapReduceDocumentsChain } = await Promise.resolve().then(function () { return combine_docs_chain; });
-                return MapReduceDocumentsChain.deserialize(data);
-            }
-            case "refine_documents_chain": {
-                const { RefineDocumentsChain } = await Promise.resolve().then(function () { return combine_docs_chain; });
-                return RefineDocumentsChain.deserialize(data);
-            }
-            case "vector_db_qa": {
-                const { VectorDBQAChain } = await Promise.resolve().then(function () { return vector_db_qa; });
-                return VectorDBQAChain.deserialize(data, values);
-            }
-            case "api_chain": {
-                const { APIChain } = await Promise.resolve().then(function () { return api_chain; });
-                return APIChain.deserialize(data);
-            }
-            default:
-                throw new Error(`Invalid prompt type in config: ${data._type}`);
+        const firstCommit = uniqueCommits[0];
+        const lastCommit = uniqueCommits[uniqueCommits.length - 1];
+        if (!firstCommit || !lastCommit) {
+            logger?.log('Unable to determine first and last commit on the current branch', {
+                color: 'yellow',
+            });
+            return [];
         }
+        return await getCommitLogRange(firstCommit, lastCommit, { git, noMerges: true });
+    }
+    catch (error) {
+        logger?.log('Encountered an error getting commit log from current branch', { color: 'red' });
     }
+    return [];
 }
 
 /**
- * The NoOpOutputParser class is a type of output parser that does not
- * perform any operations on the output. It extends the BaseOutputParser
- * class and is part of the LangChain's output parsers module. This class
- * is useful in scenarios where the raw output of the Large Language
- * Models (LLMs) is required.
+ * Retrieves the SimpleGit instance for the repository.
+ * @returns {SimpleGit} The SimpleGit instance.
  */
-class NoOpOutputParser extends BaseOutputParser {
-    constructor() {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "output_parsers", "default"]
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-    }
-    static lc_name() {
-        return "NoOpOutputParser";
-    }
-    /**
-     * This method takes a string as input and returns the same string as
-     * output. It does not perform any operations on the input string.
-     * @param text The input string to be parsed.
-     * @returns The same input string without any operations performed on it.
-     */
-    parse(text) {
-        return Promise.resolve(text);
+const getRepo = () => {
+    let git;
+    try {
+        git = simpleGit();
     }
-    /**
-     * This method returns an empty string. It does not provide any formatting
-     * instructions.
-     * @returns An empty string, indicating no formatting instructions.
-     */
-    getFormatInstructions() {
-        return "";
+    catch (e) {
+        console.log('Error initializing git repo', e);
+        process.exit(1);
     }
-}
+    return git;
+};
 
-function isBaseLanguageModel(llmLike) {
-    return typeof llmLike._llmType === "function";
-}
-function _getLanguageModel(llmLike) {
-    if (isBaseLanguageModel(llmLike)) {
-        return llmLike;
-    }
-    else if ("bound" in llmLike && Runnable.isRunnable(llmLike.bound)) {
-        return _getLanguageModel(llmLike.bound);
-    }
-    else if ("runnable" in llmLike &&
-        "fallbacks" in llmLike &&
-        Runnable.isRunnable(llmLike.runnable)) {
-        return _getLanguageModel(llmLike.runnable);
-    }
-    else if ("default" in llmLike && Runnable.isRunnable(llmLike.default)) {
-        return _getLanguageModel(llmLike.default);
-    }
-    else {
-        throw new Error("Unable to extract BaseLanguageModel from llmLike object.");
-    }
-}
 /**
- * @deprecated This class will be removed in 1.0.0. Use the LangChain Expression Language (LCEL) instead.
- * See the example below for how to use LCEL with the LLMChain class:
- *
- * Chain to run queries against LLMs.
- *
- * @example
- * ```ts
- * import { ChatPromptTemplate } from "@langchain/core/prompts";
- * import { ChatOpenAI } from "@langchain/openai";
+ * Template for generating git commit messages based on code changes
  *
- * const prompt = ChatPromptTemplate.fromTemplate("Tell me a {adjective} joke");
- * const llm = new ChatOpenAI();
- * const chain = prompt.pipe(llm);
+ * Variables:
+ * - summary: Contains the diff summary of staged changes
+ * - format_instructions: Instructions for the output format (JSON with title and body)
+ * - additional_context: Optional user-provided context to guide the commit message generation
+ * - commit_history: Optional history of previous commits for context
+ * - branch_name_context: String containing formatted branch name (or empty if disabled)
+ */
+const template$4 = `Write informative git commit message, in the imperative, based on the diffs & file changes provided in the "Diff Summary" section.
+Commit Messages must have a short description that is less than 50 characters and a longer detailed summary around 300 characters, the shorter and more concise the better.
+
+Please follow the guidelines below when writing your commit message:
+
+- Write concisely using an informal tone
+- Avoid phrases like "this commit", "this change", "this function", etc. Instead refer to the function, variable, or class by name
+- Avoid referencing specific files names or long paths in the commit message
+- DO NOT include any diffs or file changes in the commit message
+- Wrap variable, class, function, components, and dependency names in back ticks e.g. \`variable\`
+
+""""""
+{{summary}}
+""""""
+
+{{branch_name_context}}
+
+{{format_instructions}}
+
+{{commit_history}}
+
+{{additional_context}}
+`;
+// Define the variables that will be passed to the prompt template
+const inputVariables$3 = ['summary', 'format_instructions', 'additional_context', 'commit_history', 'branch_name_context'];
+const COMMIT_PROMPT = new PromptTemplate({
+    template: template$4,
+    inputVariables: inputVariables$3,
+});
+const CONVENTIONAL_TEMPLATE = `Generate a commit message that strictly adheres to the Conventional Commits specification. Follow these rules precisely:
+
+1. Type Selection:
+   - Choose ONE of these types based on the changes:
+     * feat: A new feature
+     * fix: A bug fix
+     * docs: Documentation only changes
+     * style: Changes that don't affect the code's meaning (white-space, formatting, etc)
+     * refactor: Code changes that neither fix a bug nor add a feature
+     * perf: Code changes that improve performance
+     * test: Adding missing tests or correcting existing tests
+     * build: Changes that affect the build system or external dependencies
+     * ci: Changes to CI configuration files and scripts
+     * chore: Other changes that don't modify src or test files
+     * revert: Reverts a previous commit
+
+2. Format Requirements:
+   - Title format: <type>(<optional-scope>): <description>
+   - Title must be 50 characters or less
+   - Description should be in imperative mood (e.g., "add" not "adds/added")
+   - Body MUST be 280 characters or less
+   - Separate body from title with a blank line
+   - Body should explain the motivation for the change and contrast it with previous behavior
+
+3. Scope Guidelines:
+   - If the change affects a specific component/area, include it as a scope
+   - Scope should be a noun in parentheses (e.g., (parser), (ui), (config))
+   - Omit scope if the change is broad or affects multiple areas
+
+Based on the following diff summary, generate a conventional commit message that follows these rules exactly:
+
+""""""
+{{summary}}
+""""""
+
+{{branch_name_context}}
+
+{{format_instructions}}
+
+{{commit_history}}
+
+{{additional_context}}
+
+Remember:
+- Be concise and precise
+- Focus on WHAT and WHY, not HOW
+- Use imperative mood in both title and body
+- Ensure the title alone provides enough context to understand the change`;
+const conventionalInputVariables = [
+    'summary',
+    'additional_context',
+    'commit_history',
+    'format_instructions',
+    'branch_name_context',
+];
+const CONVENTIONAL_COMMIT_PROMPT = new PromptTemplate({
+    template: CONVENTIONAL_TEMPLATE,
+    inputVariables: conventionalInputVariables,
+});
+
+/**
+ * Verify template string contains all required input variables
  *
- * const response = await chain.invoke({ adjective: "funny" });
- * ```
+ * @param text template string
+ * @param inputVariables template variables
+ * @throws Error if validation fails
  */
-class LLMChain extends BaseChain {
-    static lc_name() {
-        return "LLMChain";
+function validatePromptTemplate(text, inputVariables) {
+    if (!text || text.trim() === '') {
+        throw new Error('Prompt template cannot be empty');
     }
-    get inputKeys() {
-        return this.prompt.inputVariables;
+    if (!inputVariables || inputVariables.length === 0) {
+        return; // No variables to validate
     }
-    get outputKeys() {
-        return [this.outputKey];
+    // Extract variables from template using regex to find {variable} patterns
+    // This regex matches {variable_name} with no whitespace inside braces
+    // Excludes JSON-like patterns with quotes, colons, or whitespace
+    const templateVariableRegex = /\{([^}\s:"']+)\}/g;
+    const foundVariables = new Set();
+    let match;
+    while ((match = templateVariableRegex.exec(text)) !== null) {
+        foundVariables.add(match[1]);
     }
-    constructor(fields) {
-        super(fields);
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "prompt", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
+    // Check if all required variables are present in template
+    const missingVariables = inputVariables.filter(variable => !foundVariables.has(variable));
+    if (missingVariables.length > 0) {
+        throw new Error(`Prompt template is missing required variables: ${missingVariables.map(v => `{${v}}`).join(', ')}. ` +
+            `Found variables: ${Array.from(foundVariables).map(v => `{${v}}`).join(', ') || 'none'}`);
+    }
+    // Warn about unused variables in template (optional check)
+    const unusedVariables = Array.from(foundVariables).filter(variable => !inputVariables.includes(variable));
+    if (unusedVariables.length > 0) {
+        console.warn(`Prompt template contains undefined variables: ${unusedVariables.map(v => `{${v}}`).join(', ')}`);
+    }
+}
+
+async function editPrompt(options) {
+    return await editor({
+        message: 'Edit the prompt',
+        default: options.prompt?.length ? options.prompt : COMMIT_PROMPT.template,
+        waitForUseInput: false,
+        postfix: 'Press ENTER to continue',
+        validate: (text) => {
+            try {
+                validatePromptTemplate(text, COMMIT_PROMPT.inputVariables);
+                return true;
+            }
+            catch (error) {
+                return error instanceof Error ? error.message : 'Invalid prompt template';
+            }
+        },
+    });
+}
+
+async function editResult(result, options) {
+    if (options.openInEditor) {
+        return await editor({
+            message: 'Edit the commit message',
+            default: result,
+            waitForUseInput: false,
+            validate: (text) => (text ? true : 'Commit message cannot be empty'),
         });
-        Object.defineProperty(this, "llm", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
+    }
+    return result;
+}
+
+async function getUserReviewDecision({ label, descriptions, labels, enableEdit = true, enableRetry = true, enableFullRetry = true, enableModifyPrompt = true, selectLabel, }) {
+    const choices = [
+        {
+            name: labels?.approve || '✨ Looks good!',
+            value: 'approve',
+            description: descriptions?.approve || `Continue with the generated ${label}`,
+        },
+    ];
+    if (enableEdit) {
+        choices.push({
+            name: '📝 Edit',
+            value: 'edit',
+            description: descriptions?.edit || `Edit the generated ${label} before proceeding`,
         });
-        Object.defineProperty(this, "llmKwargs", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
+    }
+    if (enableModifyPrompt) {
+        choices.push({
+            name: '🪶  Modify Prompt',
+            value: 'modifyPrompt',
+            description: descriptions?.modifyPrompt || `Modify the prompt template and regenerate the ${label}`,
         });
-        Object.defineProperty(this, "outputKey", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: "text"
+    }
+    if (enableRetry) {
+        choices.push({
+            name: labels?.retryMessageOnly || '🔄 Retry',
+            value: 'retryMessageOnly',
+            description: descriptions?.retryMessageOnly ||
+                `Restart the function execution from generating the ${label}`,
         });
-        Object.defineProperty(this, "outputParser", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
+    }
+    if (enableFullRetry) {
+        choices.push({
+            name: labels?.retryFull || '🔄 Retry Full',
+            value: 'retryFull',
+            description: descriptions?.retryFull ||
+                `Restart the function execution from the beginning, regenerating both the summary and ${label}`,
         });
-        this.prompt = fields.prompt;
-        this.llm = fields.llm;
-        this.llmKwargs = fields.llmKwargs;
-        this.outputKey = fields.outputKey ?? this.outputKey;
-        this.outputParser =
-            fields.outputParser ?? new NoOpOutputParser();
-        if (this.prompt.outputParser) {
-            if (fields.outputParser) {
-                throw new Error("Cannot set both outputParser and prompt.outputParser");
-            }
-            this.outputParser = this.prompt.outputParser;
-        }
     }
-    getCallKeys() {
-        const callKeys = "callKeys" in this.llm ? this.llm.callKeys : [];
-        return callKeys;
+    choices.push({
+        name: labels?.cancel || '💣 Cancel',
+        value: 'cancel',
+        description: descriptions?.cancel || `Cancel the ${label}`,
+    });
+    return (await select({
+        message: selectLabel || `Would you like to make any changes to the ${label}?`,
+        choices,
+    }));
+}
+
+function logResult(label, result) {
+    console.log(`\n${chalk.bgBlue(chalk.bold(`Proposed ${label}:`))}\n${SEPERATOR}\n${result}\n${SEPERATOR}\n`);
+}
+
+async function generateAndReviewLoop({ label, factory, parser, noResult, agent, reviewParser, options, }) {
+    const { logger } = options;
+    let continueLoop = true;
+    let modifyPrompt = false;
+    let context = '';
+    let result = '';
+    const changes = await factory();
+    // if we don't have any changes, bail.
+    if (!changes || !Object.keys(changes).length) {
+        await noResult(options);
     }
-    /** @ignore */
-    _selectMemoryInputs(values) {
-        const valuesForMemory = super._selectMemoryInputs(values);
-        const callKeys = this.getCallKeys();
-        for (const key of callKeys) {
-            if (key in values) {
-                delete valuesForMemory[key];
-            }
+    while (continueLoop) {
+        if (!context.length) {
+            context = await parser(changes, result, options);
         }
-        return valuesForMemory;
-    }
-    /** @ignore */
-    async _getFinalOutput(generations, promptValue, runManager) {
-        let finalCompletion;
-        if (this.outputParser) {
-            finalCompletion = await this.outputParser.parseResultWithPrompt(generations, promptValue, runManager?.getChild());
+        // if we still don't have a context, bail.
+        if (!context.length) {
+            await noResult(options);
         }
-        else {
-            finalCompletion = generations[0].text;
+        if (modifyPrompt) {
+            options.prompt = await editPrompt(options);
         }
-        return finalCompletion;
-    }
-    /**
-     * Run the core logic of this chain and add to output if desired.
-     *
-     * Wraps _call and handles memory.
-     */
-    call(values, config) {
-        return super.call(values, config);
-    }
-    /** @ignore */
-    async _call(values, runManager) {
-        const valuesForPrompt = { ...values };
-        const valuesForLLM = {
-            ...this.llmKwargs,
-        };
-        const callKeys = this.getCallKeys();
-        for (const key of callKeys) {
-            if (key in values) {
-                if (valuesForLLM) {
-                    valuesForLLM[key] =
-                        values[key];
-                    delete valuesForPrompt[key];
-                }
+        logger.startTimer().startSpinner(`Generating ${label}\n`, {
+            color: 'blue',
+        });
+        try {
+            result = await agent(context, options);
+            if (!result) {
+                logger.stopSpinner('💀 Agent failed to return content.', {
+                    mode: 'fail',
+                    color: 'red',
+                });
+                process.exit(0);
             }
         }
-        const promptValue = await this.prompt.formatPromptValue(valuesForPrompt);
-        if ("generatePrompt" in this.llm) {
-            const { generations } = await this.llm.generatePrompt([promptValue], valuesForLLM, runManager?.getChild());
-            return {
-                [this.outputKey]: await this._getFinalOutput(generations[0], promptValue, runManager),
-            };
+        catch (error) {
+            // Handle special regeneration request from validation
+            if (error.message === 'REGENERATE_COMMIT_MESSAGE') {
+                logger.stopSpinner('Regenerating commit message...', {
+                    mode: 'stop',
+                    color: 'blue',
+                });
+                result = '';
+                continue;
+            }
+            // Re-throw other errors
+            throw error;
         }
-        const modelWithParser = this.outputParser
-            ? this.llm.pipe(this.outputParser)
-            : this.llm;
-        const response = await modelWithParser.invoke(promptValue, runManager?.getChild());
-        return {
-            [this.outputKey]: response,
-        };
-    }
-    /**
-     * Format prompt with values and pass to LLM
-     *
-     * @param values - keys to pass to prompt template
-     * @param callbackManager - CallbackManager to use
-     * @returns Completion from LLM.
-     *
-     * @example
-     * ```ts
-     * llm.predict({ adjective: "funny" })
-     * ```
-     */
-    async predict(values, callbackManager) {
-        const output = await this.call(values, callbackManager);
-        return output[this.outputKey];
-    }
-    _chainType() {
-        return "llm";
-    }
-    static async deserialize(data) {
-        const { llm, prompt } = data;
-        if (!llm) {
-            throw new Error("LLMChain must have llm");
+        logger
+            .stopSpinner(`Generated ${label}`, {
+            color: 'green',
+            mode: 'succeed',
+        })
+            .stopTimer();
+        if (options?.interactive) {
+            logResult(label, reviewParser ? reviewParser(result, options) : result);
+            const reviewAnswer = await getUserReviewDecision({
+                label,
+                ...(options?.review || {}),
+            });
+            if (reviewAnswer === 'cancel') {
+                process.exit(0);
+            }
+            if (reviewAnswer === 'edit') {
+                options.openInEditor = true;
+            }
+            if (reviewAnswer === 'retryFull') {
+                context = '';
+                result = '';
+                options.prompt = '';
+                continue;
+            }
+            if (reviewAnswer === 'retryMessageOnly') {
+                modifyPrompt = false;
+                result = '';
+                continue;
+            }
+            if (reviewAnswer === 'modifyPrompt') {
+                modifyPrompt = true;
+                result = '';
+                continue;
+            }
+            // Only edit the result in interactive mode if approved
+            result = await editResult(result, options);
         }
-        if (!prompt) {
-            throw new Error("LLMChain must have prompt");
+        else {
+            // In non-interactive mode, we return the result as is to be output to stdout by the caller.
+            const displayResult = reviewParser ? reviewParser(result, options) : result;
+            // In non-interactive mode, ensure we return the properly formatted result
+            result = displayResult;
         }
-        return new LLMChain({
-            llm: await BaseLanguageModel.deserialize(llm),
-            prompt: await BasePromptTemplate.deserialize(prompt),
-        });
+        // if we're here, we're done.
+        continueLoop = false;
     }
-    /** @deprecated */
-    serialize() {
-        const serialize = "serialize" in this.llm ? this.llm.serialize() : undefined;
-        return {
-            _type: `${this._chainType()}_chain`,
-            llm: serialize,
-            prompt: this.prompt.serialize(),
-        };
+    return result;
+}
+
+const logSuccess = () => {
+    console.log(chalk.green(chalk.bold('\nAll set! 🦾🤖')));
+};
+
+async function handleResult({ result, mode, interactiveModeCallback }) {
+    switch (mode) {
+        case 'interactive':
+            if (interactiveModeCallback) {
+                await interactiveModeCallback(result);
+            }
+            else {
+                console.warn('No result handler provided for interactive mode.');
+                logSuccess();
+            }
+            break;
+        case 'stdout':
+        default:
+            // Ensure we write the result to stdout in non-interactive mode
+            process.stdout.write(result + '\n', 'utf8');
+            break;
     }
-    _getNumTokens(text) {
-        return _getLanguageModel(this.llm).getNumTokens(text);
+    if (process.env.NODE_ENV !== 'test') {
+        process.exit(0);
     }
 }
 
-var llm_chain = /*#__PURE__*/Object.freeze({
-  __proto__: null,
-  LLMChain: LLMChain
-});
+const template$3 = `Write informative git changelog, in the imperative, based on a series of individual messages.
 
-const NAIVE_FIX_TEMPLATE = `Instructions:
---------------
-{instructions}
---------------
-Completion:
---------------
-{completion}
---------------
+- Annotate  each change with the git commit hash as reference, including just the first 7 characters
+- Logically group changes, and if necessary, summarize dependency updates
+- Include a descriptive title for the changelog, to give a high-level overview of the changes
+- Depending on the size of the changes, consider breaking the changelog into sections
+- Avoid generlizations like "various bug fixes" or "improvements" or "enhancements"
 
-Above, the Completion did not satisfy the constraints given in the Instructions.
-Error:
---------------
-{error}
---------------
+{{format_instructions}}
 
-Please try again. Please only respond with an answer that satisfies the constraints laid out in the Instructions:`;
-const NAIVE_FIX_PROMPT = 
-/* #__PURE__ */ PromptTemplate.fromTemplate(NAIVE_FIX_TEMPLATE);
+"""{{summary}}"""`;
+const inputVariables$2 = ['format_instructions', 'summary'];
+const CHANGELOG_PROMPT = new PromptTemplate({
+    template: template$3,
+    inputVariables: inputVariables$2,
+});
 
-function isLLMChain(x) {
-    return (x.prompt !== undefined && x.llm !== undefined);
-}
-/**
- * Class that extends the BaseOutputParser to handle situations where the
- * initial parsing attempt fails. It contains a retryChain for retrying
- * the parsing process in case of a failure.
- */
-class OutputFixingParser extends BaseOutputParser {
-    static lc_name() {
-        return "OutputFixingParser";
-    }
-    /**
-     * Static method to create a new instance of OutputFixingParser using a
-     * given language model, parser, and optional fields.
-     * @param llm The language model to be used.
-     * @param parser The parser to be used.
-     * @param fields Optional fields which may contain a prompt.
-     * @returns A new instance of OutputFixingParser.
-     */
-    static fromLLM(llm, parser, fields) {
-        const prompt = fields?.prompt ?? NAIVE_FIX_PROMPT;
-        const chain = new LLMChain({ llm, prompt });
-        return new OutputFixingParser({ parser, retryChain: chain });
+const handler$4 = async (argv, logger) => {
+    const config = loadConfig(argv);
+    const git = getRepo();
+    const key = getApiKeyForModel(config);
+    const { provider, model } = getModelAndProviderFromConfig(config);
+    if (config.service.authentication.type !== 'None' && !key) {
+        logger.log(`No API Key found. 🗝️🚪`, { color: 'red' });
+        process.exit(1);
     }
-    constructor({ parser, retryChain, }) {
-        super(...arguments);
-        Object.defineProperty(this, "lc_namespace", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: ["langchain", "output_parsers", "fix"]
-        });
-        Object.defineProperty(this, "lc_serializable", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: true
-        });
-        Object.defineProperty(this, "parser", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        Object.defineProperty(this, "retryChain", {
-            enumerable: true,
-            configurable: true,
-            writable: true,
-            value: void 0
-        });
-        this.parser = parser;
-        this.retryChain = retryChain;
+    const llm = getLlm(provider, model, config);
+    const INTERACTIVE = isInteractive(config);
+    if (INTERACTIVE) {
+        if (!config.hideCocoBanner) {
+            logger.log(LOGO);
+        }
     }
-    /**
-     * Method to parse the completion using the parser. If the initial parsing
-     * fails, it uses the retryChain to attempt to fix the output and retry
-     * the parsing process.
-     * @param completion The completion to be parsed.
-     * @param callbacks Optional callbacks to be used during parsing.
-     * @returns The parsed output.
-     */
-    async parse(completion, callbacks) {
-        try {
-            return await this.parser.parse(completion, callbacks);
+    async function factory() {
+        const branchName = await getCurrentBranchName({ git });
+        if (config.sinceLastTag) {
+            logger.verbose(`Generating commit log since the last tag`, { color: 'yellow' });
+            return {
+                branch: branchName,
+                commits: await getChangesSinceLastTag({ git, logger }),
+            };
         }
-        catch (e) {
-            // eslint-disable-next-line no-instanceof/no-instanceof
-            if (e instanceof OutputParserException) {
-                const retryInput = {
-                    instructions: this.parser.getFormatInstructions(),
-                    completion,
-                    error: e,
-                };
-                if (isLLMChain(this.retryChain)) {
-                    const result = await this.retryChain.call(retryInput, callbacks);
-                    const newCompletion = result[this.retryChain.outputKey];
-                    return this.parser.parse(newCompletion, callbacks);
-                }
-                else {
-                    const result = await this.retryChain.invoke(retryInput, {
-                        callbacks,
-                    });
-                    return result;
-                }
+        if (config.range && config.range.includes(':')) {
+            const [from, to] = config.range.split(':');
+            if (!from || !to) {
+                logger.log(`Invalid range provided. Expected format is <from>:<to>`, { color: 'red' });
+                process.exit(1);
             }
-            throw e;
+            return {
+                branch: branchName,
+                commits: await getCommitLogRange(from, to, { git, noMerges: true }),
+            };
+        }
+        if (argv.branch) {
+            logger.verbose(`Generating commit log against branch: ${argv.branch}`, { color: 'yellow' });
+            return {
+                branch: branchName,
+                commits: await getCommitLogAgainstBranch({ git, logger, targetBranch: argv.branch }),
+            };
         }
+        logger.verbose(`No range, branch, or tag option provided. Defaulting to current branch`, {
+            color: 'yellow',
+        });
+        const commits = await getCommitLogCurrentBranch({ git, logger });
+        return {
+            branch: branchName,
+            commits,
+        };
     }
-    /**
-     * Method to get the format instructions for the parser.
-     * @returns The format instructions for the parser.
-     */
-    getFormatInstructions() {
-        return this.parser.getFormatInstructions();
+    async function parser({ branch, commits }) {
+        let result;
+        if (!commits || commits.length === 0) {
+            result = `## ${branch}\n\nNo commits found.`;
+        }
+        else {
+            result = `## ${branch}\n\n${commits.map((commit) => commit.trim()).join('\n\n')}`;
+        }
+        return result;
     }
-}
+    const changelogMsg = await generateAndReviewLoop({
+        label: 'changelog',
+        options: {
+            ...config,
+            prompt: config.prompt || CHANGELOG_PROMPT.template,
+            logger,
+            interactive: INTERACTIVE,
+            review: {
+                enableFullRetry: false,
+            },
+        },
+        factory,
+        parser,
+        agent: async (context, options) => {
+            const parser = createSchemaParser(ChangelogResponseSchema, llm);
+            const prompt = getPrompt({
+                template: options.prompt,
+                variables: CHANGELOG_PROMPT.inputVariables,
+                fallback: CHANGELOG_PROMPT,
+            });
+            const formatInstructions = "Only respond with a valid JSON object, containing two fields: 'title' an escaped string, no more than 65 characters, and 'content' also an escaped string.";
+            const changelog = await executeChain({
+                llm,
+                prompt,
+                variables: {
+                    summary: context,
+                    format_instructions: formatInstructions,
+                },
+                parser,
+            });
+            const branchName = await getCurrentBranchName({ git });
+            const ticketId = extractTicketIdFromBranchName(branchName);
+            const footer = ticketId ? `\n\nPart of **${ticketId}**` : '';
+            return `${changelog.title}\n\n${changelog.content}${footer}`;
+        },
+        noResult: async () => {
+            if (config.range) {
+                logger.log(`No commits found in the provided range.`, { color: 'red' });
+                process.exit(0);
+            }
+            logger.log(`No commits found in the current branch.`, { color: 'red' });
+            process.exit(0);
+        },
+    });
+    const MODE = (INTERACTIVE && 'interactive') || (config.commit && 'interactive') || config?.mode || 'stdout';
+    handleResult({
+        result: changelogMsg,
+        interactiveModeCallback: async () => {
+            logSuccess();
+        },
+        mode: MODE,
+    });
+};
+
+var changelog = {
+    command: command$4,
+    desc: 'Generate a changelog from current or target branch, provided commit range, or since the last tag.',
+    builder: builder$4,
+    handler: commandExecutor(handler$4),
+    options: options$4,
+};
 
+const conventionalTypeRegex = /^(feat|fix|docs|style|refactor|perf|test|build|ci|chore|revert)(\(.+\))?:/;
+// Regular commit message schema with basic validation
+const CommitMessageResponseSchema = objectType({
+    title: stringType(),
+    body: stringType(),
+});
+// Conventional commit message schema with strict formatting rules
+const ConventionalCommitMessageResponseSchema = objectType({
+    title: stringType()
+        .max(50, "Title must be 50 characters or less")
+        .refine((title) => conventionalTypeRegex.test(title), "Title must follow Conventional Commits format (e.g., 'feat: add new feature' or 'fix(scope): fix bug')"),
+    body: stringType()
+    // .max(280, "Body must be 280 characters or less"),
+});
+const command$3 = 'commit';
 /**
- * Creates a parser with built-in retry logic for schema-based generation
- * @param schema - Zod schema for the expected output structure
- * @param llm - LLM instance for retry attempts
- * @param options - Configuration options for retry behavior
- * @returns OutputFixingParser configured with retry logic
- * @throws LangChainExecutionError if parser creation fails
+ * Command line options via yargs
  */
-function createSchemaParser(schema, llm, options = {}) {
-    validateRequired(schema, 'schema', 'createSchemaParser');
-    validateRequired(llm, 'llm', 'createSchemaParser');
-    validateRequired(options, 'options', 'createSchemaParser');
-    // Validate schema is actually a Zod schema
-    if (typeof schema.parse !== 'function') {
-        throw new LangChainExecutionError('createSchemaParser: Schema must be a valid Zod schema with a parse method', { schemaType: typeof schema, hasParseMethod: typeof schema.parse });
-    }
-    // Validate options structure
-    if (typeof options !== 'object' || Array.isArray(options)) {
-        throw new LangChainExecutionError('createSchemaParser: Options must be a non-array object', { options, type: typeof options, isArray: Array.isArray(options) });
-    }
-    const { retryTemplate } = options;
-    // Validate retryTemplate if provided
-    if (retryTemplate !== undefined && typeof retryTemplate !== 'string') {
-        throw new LangChainExecutionError('createSchemaParser: retryTemplate must be a string when provided', { retryTemplate, type: typeof retryTemplate });
-    }
-    try {
-        const baseParser = new StructuredOutputParser(schema);
-        const defaultRetryTemplate = `The following text failed to parse as valid JSON. Please convert it into a valid JSON object that matches the required schema.
-
-## Text to fix:
-{completion}
-
-## Instructions: 
-{instructions}
-
-You must return ONLY valid JSON that matches the schema exactly. Do not include any additional text, explanations, or markdown formatting:`;
-        const retryPromptTemplate = new PromptTemplate({
-            template: retryTemplate || defaultRetryTemplate,
-            inputVariables: ['completion', 'instructions'],
-        });
-        const retryChain = retryPromptTemplate.pipe(llm).pipe(baseParser);
-        return new OutputFixingParser({
-            parser: baseParser,
-            retryChain: retryChain,
-        });
-    }
-    catch (error) {
-        handleLangChainError(error, 'createSchemaParser: Failed to create schema parser', {
-            schemaName: schema.constructor.name,
-            llmType: llm.constructor.name,
-            hasRetryTemplate: !!retryTemplate
-        });
-    }
-}
+const options$3 = {
+    i: {
+        alias: 'interactive',
+        description: 'Toggle interactive mode',
+        type: 'boolean',
+    },
+    ignoredFiles: {
+        description: 'Ignored files',
+        type: 'array',
+    },
+    ignoredExtensions: {
+        description: 'Ignored extensions',
+        type: 'array',
+    },
+    append: {
+        description: 'Add content to the end of the generated commit message',
+        type: 'string',
+    },
+    appendTicket: {
+        description: 'Append ticket ID from branch name to the commit message',
+        type: 'boolean',
+        alias: 't',
+    },
+    additional: {
+        description: 'Add extra contextual information to the prompt',
+        type: 'string',
+        alias: 'a',
+    },
+    withPreviousCommits: {
+        description: 'Include previous commits as context (specify number of commits, 0 for none)',
+        type: 'number',
+        default: 0,
+        alias: 'p',
+    },
+    conventional: {
+        description: 'Generate commit message in Conventional Commits format',
+        type: 'boolean',
+        default: false,
+        alias: 'c',
+    },
+    includeBranchName: {
+        description: 'Include the current branch name in the commit prompt for context',
+        type: 'boolean',
+        default: true,
+    },
+    noDiff: {
+        description: 'Only pass basic "git status" result instead of providing entire diff',
+        type: 'boolean',
+        default: false,
+    },
+};
+const builder$3 = (yargs) => {
+    return yargs.options(options$3).usage(getCommandUsageHeader(command$3));
+};
 
 /**
  * High-level function that combines chain execution with schema-based parsing
@@ -7901,7 +7904,38 @@ async function parseDefaultFileDiff(nodeFile, commit = '--staged', git) {
             throw new Error(`Error reading untracked file: ${error?.message || 'Unknown error'}`);
         }
     }
-    return await git.diff([commit, nodeFile.filePath]);
+    // For branch comparisons, handle files that may not exist in the base branch
+    try {
+        return await git.diff([commit, nodeFile.filePath]);
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        // If the error indicates the file doesn't exist in the base branch, handle it gracefully
+        if (errorMessage.includes('unknown revision or path not in the working tree') ||
+            errorMessage.includes('ambiguous argument')) {
+            // This is likely a newly added file - show the entire file content as an addition
+            if (nodeFile.status === 'added') {
+                try {
+                    const fileContent = await promises.readFile(nodeFile.filePath, 'utf-8');
+                    return `+++ ${nodeFile.filePath}\n${fileContent.split('\n').map(line => `+${line}`).join('\n')}`;
+                }
+                catch (fsError) {
+                    return `Error reading added file ${nodeFile.filePath}: ${fsError instanceof Error ? fsError.message : String(fsError)}`;
+                }
+            }
+            // For other cases, try to get the file content from the current HEAD
+            try {
+                const fileContent = await git.show([`HEAD:${nodeFile.filePath}`]);
+                return `File content from current version:\n${fileContent}`;
+            }
+            catch (showError) {
+                // If all else fails, provide a meaningful error message
+                return `Unable to retrieve diff for ${nodeFile.filePath}. File may be newly added or renamed.`;
+            }
+        }
+        // Re-throw other types of errors
+        throw error;
+    }
 }
 /**
  * Parses the diff for a renamed file.
@@ -11756,6 +11790,10 @@ const options$1 = {
         type: 'boolean',
         description: 'Recap for last tag',
     },
+    currentBranch: {
+        type: 'boolean',
+        description: 'Recap for the current branch',
+    },
     i: {
         type: 'boolean',
         alias: 'interactive',
@@ -11771,8 +11809,89 @@ const getChangesByTimestamp = async ({ since, git }) => {
     return formatCommitLog(commitLog);
 };
 
+/**
+ * Retrieves the diff between the current branch and a specified target branch.
+ *
+ * @param {Object} options - The options for retrieving the diff.
+ * @param {SimpleGit} options.git - The SimpleGit instance.
+ * @param {Logger} options.logger - The logger for logging messages.
+ * @param {string} options.baseBranch - The base branch to compare against.
+ * @param {string} options.headBranch - The head branch to compare.
+ * @param {string[]} options.ignoredFiles - Array of specific files to ignore.
+ * @param {string[]} options.ignoredExtensions - Array of file extensions to ignore.
+ * @returns {Promise<GetChangesResult>} The diff between the current branch and the target branch.
+ */
+async function getDiffForBranch({ git, logger, baseBranch, headBranch, options, }) {
+    try {
+        logger?.verbose(`Getting diff for branches: baseBranch="${baseBranch}", headBranch="${headBranch}"`, {
+            color: 'blue',
+        });
+        // Validate branch names
+        if (!baseBranch || !headBranch) {
+            throw new Error(`Invalid branch names: baseBranch="${baseBranch}", headBranch="${headBranch}"`);
+        }
+        const { ignoredFiles = [], ignoredExtensions = [] } = options || {};
+        // Prepare ignore patterns
+        const ignorePatterns = [
+            ...ignoredFiles.map((file) => `:!${file}`),
+            ...ignoredExtensions.map((ext) => `:!*${ext}`),
+        ];
+        // Construct the diff command
+        const diffArgs = [`${baseBranch}..${headBranch}`];
+        if (ignorePatterns.length > 0) {
+            diffArgs.push('--');
+            diffArgs.push(...ignorePatterns);
+        }
+        logger?.verbose(`Running git diff with args: ${diffArgs.join(' ')}`, {
+            color: 'blue',
+        });
+        // Get the diff
+        const diff = await git.diff(diffArgs);
+        logger?.verbose(`Generated diff between "${headBranch}" and "${baseBranch}"`, {
+            color: 'blue',
+        });
+        const changes = diff.split('diff --git').slice(1).map((fileDiff) => {
+            const lines = fileDiff.split('\n');
+            const filePathLine = lines[0];
+            const filePath = filePathLine.split('b/')[1]?.split(' ')[0];
+            const oldFilePath = filePathLine.split('a/')[1]?.split(' ')[0];
+            // Determine status based on diff headers
+            let status = 'modified';
+            if (fileDiff.includes('new file mode')) {
+                status = 'added';
+            }
+            else if (fileDiff.includes('deleted file mode')) {
+                status = 'deleted';
+            }
+            else if (fileDiff.includes('rename from')) {
+                status = 'renamed';
+            }
+            return {
+                filePath: filePath || '',
+                oldFilePath: oldFilePath || '',
+                status,
+                summary: getSummaryText({ path: filePath || '', index: '', working_dir: '' }, { filePath: filePath || '', status }),
+            };
+        });
+        return {
+            staged: changes,
+            unstaged: [],
+            untracked: [],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        console.error('Error in getDiffForBranch:', error);
+        logger?.log(`Encountered an error getting diff between branches: ${errorMessage}`, { color: 'red' });
+        logger?.log(`Branch details: baseBranch="${baseBranch}", headBranch="${headBranch}"`, { color: 'red' });
+        // Re-throw the error so the caller can handle it appropriately
+        throw error;
+    }
+}
+
 async function noResult$1({ logger }) {
     logger.log('No repo changes detected. 👀', { color: 'blue' });
+    throw new Error('NO_CHANGES_DETECTED');
 }
 
 const template$1 = `Following the formatting instructions, summarize the following changes in the underlying git repository/branch.  
@@ -11820,7 +11939,9 @@ const handler$1 = async (argv, logger) => {
                 ? 'yesterday'
                 : lastWeek
                     ? 'last-week'
-                    : 'current';
+                    : argv.currentBranch || config.currentBranch
+                        ? 'currentBranch'
+                        : 'current';
     logger.log(`Generating recap for timeframe: ${timeframe}`);
     async function factory() {
         switch (timeframe) {
@@ -11861,6 +11982,25 @@ const handler$1 = async (argv, logger) => {
             case 'last-tag':
                 const tags = await getChangesSinceLastTag({ git });
                 return tags;
+            case 'currentBranch':
+                const currentBranch = await getCurrentBranchName({ git });
+                const baseBranch = config.defaultBranch || 'main';
+                logger.log(`Recapping changes on branch '${currentBranch}' compared to '${baseBranch}'`);
+                const changes = await getDiffForBranch({
+                    git,
+                    baseBranch,
+                    headBranch: currentBranch,
+                    options: {
+                        ignoredFiles: config.ignoredFiles || undefined,
+                        ignoredExtensions: config.ignoredExtensions || undefined,
+                    },
+                });
+                const branchChanges = await fileChangeParser({
+                    changes: changes.staged,
+                    commit: baseBranch,
+                    options: { tokenizer, git, llm, logger },
+                });
+                return [branchChanges];
             default:
                 logger.log(`Invalid timeframe: ${timeframe}`, { color: 'red' });
                 return [];
@@ -11901,7 +12041,7 @@ const handler$1 = async (argv, logger) => {
                 fallback: RECAP_PROMPT,
             });
             try {
-                const parser = new StructuredOutputParser(RecapLlmResponseSchema);
+                const parser = createSchemaParser(RecapLlmResponseSchema, llm);
                 const response = await executeChain({
                     llm,
                     prompt,
@@ -11933,11 +12073,13 @@ ${errorMessage}
         },
         noResult: async () => {
             await noResult$1({ git, logger });
-            process.exit(0);
+            if (process.env.NODE_ENV !== 'test') {
+                process.exit(0);
+            }
         },
     });
     // Handle the result based on the mode (interactive or stdout)
-    const MODE = (INTERACTIVE && 'interactive') || (config.recap && 'interactive') || config?.mode || 'stdout'; // Default to stdout
+    const MODE = (INTERACTIVE && 'interactive') ?? (config.recap && 'interactive') ?? config?.mode ?? 'stdout'; // Default to stdout
     handleResult({
         result: recapResult,
         interactiveModeCallback: async () => {
@@ -11995,46 +12137,6 @@ const builder = (yargs) => {
     return yargs.options(options).usage(getCommandUsageHeader(command));
 };
 
-/**
- * Retrieves the diff between the current branch and a specified target branch.
- *
- * @param {Object} options - The options for retrieving the diff.
- * @param {SimpleGit} options.git - The SimpleGit instance.
- * @param {Logger} options.logger - The logger for logging messages.
- * @param {string} options.targetBranch - The target branch to compare against.
- * @param {string[]} options.ignoredFiles - Array of specific files to ignore.
- * @param {string[]} options.ignoredExtensions - Array of file extensions to ignore.
- * @returns {Promise<string>} The diff between the current branch and the target branch.
- */
-async function getDiffForBranch({ git, logger, targetBranch, ignoredFiles = [], ignoredExtensions = [], }) {
-    try {
-        // Get the current branch name
-        const currentBranch = await getCurrentBranchName({ git });
-        // Prepare ignore patterns
-        const ignorePatterns = [
-            ...ignoredFiles.map((file) => `:!${file}`),
-            ...ignoredExtensions.map((ext) => `:!*${ext}`),
-        ];
-        // Construct the diff command
-        const diffArgs = [`${targetBranch}..${currentBranch}`];
-        if (ignorePatterns.length > 0) {
-            diffArgs.push('--');
-            diffArgs.push(...ignorePatterns);
-        }
-        // Get the diff
-        const diff = await git.diff(diffArgs);
-        logger?.verbose(`Generated diff between "${currentBranch}" and "${targetBranch}"`, {
-            color: 'blue',
-        });
-        return diff;
-    }
-    catch (error) {
-        console.error('Error in getDiffForBranch:', error);
-        logger?.log('Encountered an error getting diff between branches', { color: 'red' });
-        return '';
-    }
-}
-
 /******************************************************************************
 Copyright (c) Microsoft Corporation.
 
@@ -14251,14 +14353,23 @@ const handler = async (argv, logger) => {
     async function factory() {
         if (argv.branch) {
             logger.verbose(`Generating diff for branch: ${argv.branch}`, { color: 'yellow' });
+            const currentBranch = await getCurrentBranchName({ git });
             const diff = await getDiffForBranch({
                 git,
                 logger,
-                targetBranch: argv.branch,
-                ignoredFiles: config.ignoredFiles || [],
-                ignoredExtensions: config.ignoredExtensions || [],
+                baseBranch: argv.branch,
+                headBranch: currentBranch,
+                options: {
+                    ignoredFiles: config.ignoredFiles || [],
+                    ignoredExtensions: config.ignoredExtensions || [],
+                },
+            });
+            const branchChanges = await fileChangeParser({
+                changes: diff.staged,
+                commit: `--branch-diff-${argv.branch}`,
+                options: { tokenizer, git, llm, logger },
             });
-            return [diff];
+            return [branchChanges];
         }
         else {
             const { staged, unstaged, untracked } = await getChanges({
@@ -14322,7 +14433,7 @@ const handler = async (argv, logger) => {
         factory,
         parser,
         agent: async (context, options) => {
-            const parser = new StructuredOutputParser(ReviewFeedbackItemArraySchema);
+            const parser = createSchemaParser(ReviewFeedbackItemArraySchema, llm);
             const formatInstructions = "Respond with a valid JSON object, containing four fields:'title' a string, 'summary' a short summary of the problem (include line number if big file), 'severity' a numeric enum up to ten, 'category' an enum string, and 'filePath' a relative filepath to file as string.";
             const prompt = getPrompt({
                 template: options.prompt,