git-coco 0.1.0

package/dist/lib/config/default.d.ts

@@ -0,0 +1,7 @@
+import { Config } from './types';
+/**
+ * Default Config
+ *
+ * @type {Config}
+ */
+export declare const DEFAULT_CONFIG: Config;

package/dist/lib/config/index.d.ts

@@ -0,0 +1,21 @@
+import { Config } from './types';
+/**
+ * Load application config
+ *
+ * Merge config from multiple sources.
+ *
+ * \* Order of precedence:
+ * \* 1. Command line flags
+ * \* 2. Environment variables
+ * \* 3. Project config
+ * \* 4. Git config
+ * \* 5. XDG config
+ * \* 6. .gitignore
+ * \* 7. .ignore
+ * \* 8. Default config
+ *
+ * @returns {Config} application config
+ **/
+export declare function loadConfig(): Config;
+declare const config: Config;
+export default config;

package/dist/lib/config/services/env.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../types';
+/**
+ * Load environment variables
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+export declare function loadEnvConfig(config: Config): Config;

package/dist/lib/config/services/git.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../types';
+/**
+ * Load git profile config (from ~/.gitconfig)
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+export declare function loadGitConfig(config: Config): Config;

package/dist/lib/config/services/ignore.d.ts

@@ -0,0 +1,15 @@
+import { Config } from '../types';
+/**
+ * Load .gitignore in project root
+ *
+ * @param {Config} config
+ * @returns
+ */
+export declare function loadGitignore(config: Config): Config;
+/**
+ * Load .ignore in project root
+ *
+ * @param {Config} config
+ * @returns
+ */
+export declare function loadIgnore(config: Config): Config;

package/dist/lib/config/services/project.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../types';
+/**
+ * Load project config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+export declare function loadProjectConfig(config: Config): Config;

package/dist/lib/config/services/xdg.d.ts

@@ -0,0 +1,8 @@
+import { Config } from '../types';
+/**
+ * Load XDG config
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ */
+export declare function loadXDGConfig(config: Config): Config;

package/dist/lib/config/services/yargs.d.ts

@@ -0,0 +1,25 @@
+import yargs from 'yargs';
+import { Config } from '../types';
+/**
+ * Command line options via yargs
+ */
+export declare const options: Record<string, yargs.Options>;
+/**
+ * Load command line flags via yargs
+ *
+ * @returns {Partial<Config>} Updated config
+ */
+export declare const loadArgv: () => {
+    [x: string]: unknown;
+    _: (string | number)[];
+    $0: string;
+};
+/**
+ * Load command line flags
+ *
+ * Note: Arugments are parsed using yargs.
+ *
+ * @param {Config} config
+ * @returns {Config} Updated config
+ **/
+export declare function loadCmdLineFlags(config: Config): Config;

package/dist/lib/config/types.d.ts

@@ -0,0 +1,63 @@
+export interface Config {
+    /**
+     * The OpenAI API key.
+     */
+    openAIApiKey: string;
+    /**
+     * The maximum number of tokens per request.
+     *
+     * @default 1024
+     */
+    tokenLimit?: number;
+    /**
+     * The prompt text used for generating results.
+     */
+    prompt?: string;
+    /**
+     * The temperature value controls the randomness of the generated output.
+     * Higher values (e.g., 0.8) make the output more random, while lower values (e.g., 0.2) make it more deterministic.
+     *
+     * @default 0.4
+     */
+    temperature?: number;
+    /**
+     * The output destination for the generated result.
+     * - 'stdout': Prints the result to the standard output.  This is the default behavior.
+     * - 'interactive': Provides an interactive prompt for editing the result & committing the changes.
+     *
+     * @default 'stdout'
+     */
+    mode?: 'stdout' | 'interactive';
+    /**
+     * Enable verbose logging.
+     *
+     * @default false
+     */
+    verbose?: boolean;
+    /**
+     * Open the commit message in an editor for editing before proceeding.
+     *
+     * @default false
+     */
+    openInEditor?: boolean;
+    /**
+     * The prompt text used specifically for generating summaries of large files.
+     */
+    summarizePrompt?: string;
+    /**
+     * An array of file paths or patterns to be ignored during processing.
+     *
+     * Note: This is a list of patterns interpreted by the `minimatch` library.
+     * @see https://github.com/isaacs/minimatch
+     *
+     * @example ['package-lock.json', 'node_modules']
+     * @default ['package-lock.json', contents of .gitignore, contents of .ignore]
+     */
+    ignoredFiles?: string[];
+    /**
+     * An array of file extensions to be ignored during processing.
+     *
+     * @default ['.map', '.lock']
+     */
+    ignoredExtensions?: string[];
+}

package/dist/lib/langchain/chains/llm.d.ts

@@ -0,0 +1,6 @@
+import { LLMChainInput } from 'langchain/chains';
+type LLMInput = {
+    variables: Record<string, unknown>;
+} & LLMChainInput;
+export declare const llm: ({ llm, prompt, variables }: LLMInput) => Promise<any>;
+export {};

package/dist/lib/langchain/chains/summarize.d.ts

@@ -0,0 +1,11 @@
+import { MapReduceDocumentsChain, RefineDocumentsChain, StuffDocumentsChain } from 'langchain/chains';
+import { RecursiveCharacterTextSplitter } from 'langchain/text_splitter';
+import { DocumentInput } from 'langchain/document';
+export type SummarizeContext = {
+    textSplitter: RecursiveCharacterTextSplitter;
+    chain: StuffDocumentsChain | MapReduceDocumentsChain | RefineDocumentsChain;
+    options?: {
+        returnIntermediateSteps?: boolean;
+    };
+};
+export declare function summarize(documents: DocumentInput[], { chain, textSplitter, options }: SummarizeContext): Promise<string>;

package/dist/lib/langchain/prompts/commitDefault.d.ts

@@ -0,0 +1,3 @@
+import { PromptTemplate } from 'langchain/prompts';
+export declare const inputVariables: string[];
+export declare const COMMIT_PROMPT: PromptTemplate;

package/dist/lib/langchain/prompts/summarize.d.ts

@@ -0,0 +1,3 @@
+import { PromptTemplate } from 'langchain/prompts';
+export declare const inputVariables: string[];
+export declare const SUMMARIZE_PROMPT: PromptTemplate;

package/dist/lib/langchain/utils.d.ts

@@ -0,0 +1,20 @@
+import { HuggingFaceInference } from 'langchain/llms/hf';
+import { PromptTemplate } from 'langchain/prompts';
+import { SummarizationChainParams } from 'langchain/chains';
+import { BaseLLMParams } from 'langchain/llms/base';
+import { AzureOpenAIInput, OpenAIInput, OpenAI } from 'langchain/llms/openai';
+import { RecursiveCharacterTextSplitter, RecursiveCharacterTextSplitterParams } from 'langchain/text_splitter';
+import { ConfigurationParameters } from 'openai';
+export declare function getModel(fields?: (Partial<OpenAIInput> & Partial<AzureOpenAIInput> & BaseLLMParams & {
+    configuration?: ConfigurationParameters | undefined;
+}) | undefined, configuration?: ConfigurationParameters | undefined): OpenAI | HuggingFaceInference;
+export declare function getTextSplitter(options?: Partial<RecursiveCharacterTextSplitterParams>): RecursiveCharacterTextSplitter;
+export declare function getChain(model: ReturnType<typeof getModel>, options?: SummarizationChainParams): import("langchain/chains").StuffDocumentsChain | import("langchain/chains").MapReduceDocumentsChain | import("langchain/chains").RefineDocumentsChain;
+type CreatePromptInput = {
+    template?: string;
+    variables: string[];
+    fallback?: PromptTemplate;
+};
+export declare function getPrompt({ template, variables, fallback }: CreatePromptInput): PromptTemplate;
+export declare function validatePromptTemplate(text: string, inputVariables: string[]): string | true;
+export {};

package/dist/lib/parsers/default/fileChangeParser.d.ts

@@ -0,0 +1,2 @@
+import { BaseParser } from '../../types';
+export declare const fileChangeParser: BaseParser;

package/dist/lib/parsers/default/utils/collectDiffs.d.ts

@@ -0,0 +1,8 @@
+import GPT3Tokenizer from 'gpt3-tokenizer';
+import { DiffNode, FileChange } from '../../../types';
+import { Logger } from '../../../utils/logger';
+import { DiffTreeNode } from './createDiffTree';
+/**
+ * Asynchronously collect diffs for a given node and its children.
+ */
+export declare function collectDiffs(node: DiffTreeNode, getFileDiff: (change: FileChange) => Promise<string>, tokenizer: GPT3Tokenizer, logger?: Logger): Promise<DiffNode>;

package/dist/lib/parsers/default/utils/createDiffTree.d.ts

@@ -0,0 +1,12 @@
+import { FileChange } from '../../../types';
+export declare class DiffTreeNode {
+    path: string[];
+    files: FileChange[];
+    children: Map<string, DiffTreeNode>;
+    constructor(path?: string[]);
+    addFile(file: FileChange): void;
+    addChild(part: string, node: DiffTreeNode): void;
+    getChild(part: string): DiffTreeNode | undefined;
+    getPath(): string;
+}
+export declare const createDiffTree: (changes: FileChange[]) => DiffTreeNode;

package/dist/lib/parsers/default/utils/parseFileDiff.d.ts

@@ -0,0 +1,4 @@
+import { Repository, Tree, Index } from 'nodegit';
+import { FileChange } from '../../../types';
+import { Logger } from '../../../utils/logger';
+export declare const parseFileDiff: (nodeFile: FileChange, repo: Repository, headTree: Tree, index: Index, logger: Logger) => Promise<string>;

package/dist/lib/parsers/default/utils/summarizeDiffs.d.ts

@@ -0,0 +1,24 @@
+import GPT3Tokenizer from 'gpt3-tokenizer';
+import { DirectoryDiff, DiffNode } from '../../../types';
+import { SummarizeContext } from '../../../langchain/chains/summarize';
+/**
+ * Create groups from a given node info.
+ * @param {DiffNode} node - The node info to start grouping.
+ * @returns {DirectoryDiff[]} The groups created.
+ */
+export declare function createDirectoryDiffs(node: DiffNode): DirectoryDiff[];
+type SummarizeDirectoryDiffOptions = {
+    tokenizer: GPT3Tokenizer;
+} & SummarizeContext;
+/**
+ * Summarize a directory diff asynchronously.
+ */
+export declare function summarizeDirectoryDiff(directory: DirectoryDiff, { chain, textSplitter, tokenizer }: SummarizeDirectoryDiffOptions): Promise<DirectoryDiff>;
+declare const defaultOutputCallback: (group: DirectoryDiff) => string;
+type SummarizeDiffsOptions = {
+    tokenizer: GPT3Tokenizer;
+    maxTokens: number;
+    handleOutput?: typeof defaultOutputCallback;
+} & SummarizeContext;
+export declare function summarizeDiffs(rootDiffNode: DiffNode, { tokenizer, maxTokens, textSplitter, chain, handleOutput, }: SummarizeDiffsOptions): Promise<string>;
+export {};

package/dist/lib/parsers/noResult.d.ts

@@ -0,0 +1,8 @@
+import { Repository } from 'nodegit';
+import { Logger } from '../utils/logger';
+type NoResultInput = {
+    repo: Repository;
+    logger: Logger;
+};
+export declare const noResult: ({ repo, logger }: NoResultInput) => Promise<never>;
+export {};

package/dist/lib/types.d.ts

@@ -0,0 +1,34 @@
+import GPT3Tokenizer from 'gpt3-tokenizer';
+import { Repository } from 'nodegit';
+import { getModel } from './langchain/utils';
+export type FileChangeStatus = 'modified' | 'renamed' | 'added' | 'new file' | 'deleted' | 'untracked' | 'unknown';
+export interface FileChange {
+    summary: string;
+    filepath: string;
+    oldFilepath?: string;
+    status: FileChangeStatus;
+}
+export interface FileDiff {
+    file: string;
+    diff: string;
+    summary: string;
+    tokenCount: number;
+}
+export interface DiffNode {
+    path: string;
+    diffs: FileDiff[];
+    children: DiffNode[];
+}
+export interface DirectoryDiff {
+    path: string;
+    diffs: FileDiff[];
+    summary?: string;
+    tokenCount: number;
+}
+export interface BaseParser {
+    (changes: FileChange[], options: {
+        tokenizer: GPT3Tokenizer;
+        model: ReturnType<typeof getModel>;
+        repo: Repository;
+    }): Promise<string>;
+}

package/dist/lib/ui.d.ts

@@ -0,0 +1,2 @@
+export declare const logCommit: (commit: string) => void;
+export declare const logSuccess: () => void;

package/dist/lib/utils/getPathFromFilePath.d.ts

@@ -0,0 +1,6 @@
+/**
+ * Extract the path from a file path string.
+ * @param {string} filePath - The full file path.
+ * @returns {string} The path portion of the file path.
+ */
+export declare function getPathFromFilePath(filePath: string): string;

package/dist/lib/utils/getTokenizer.d.ts

@@ -0,0 +1,9 @@
+import GPT3NodeTokenizer from "gpt3-tokenizer";
+/**
+ * Wrapper around GPT3NodeTokenizer to handle default export.
+ *
+ * @see https://github.com/botisan-ai/gpt3-tokenizer/issues/18
+ *
+ * @returns {GPT3NodeTokenizer} The GPT3NodeTokenizer instance.
+ */
+export declare const getTokenizer: () => GPT3NodeTokenizer;

package/dist/lib/utils/getTruncatedFilePath.d.ts

@@ -0,0 +1 @@
+export declare function getTruncatedFilePath(filePath: string, maxLength?: number): string;

package/dist/lib/utils/git/constants.d.ts

@@ -0,0 +1 @@
+export declare const EMPTY_GIT_TREE_HASH = "4b825dc642cb6eb9a060e54bf8d69288fbee4904";

package/dist/lib/utils/git/createCommit.d.ts

@@ -0,0 +1,2 @@
+import * as nodegit from 'nodegit';
+export declare function createCommit(commitMsg: string, repo: nodegit.Repository): Promise<nodegit.Oid | null>;

package/dist/lib/utils/git/getChanges.d.ts

@@ -0,0 +1,43 @@
+import { Repository } from 'nodegit';
+import { FileChange } from '../../types';
+export type GetChangesArgs = {
+    ignoreUnstaged?: boolean;
+    ignoreUntracked?: boolean;
+    ignoredFiles?: string[];
+    ignoredExtensions?: string[];
+};
+export type GetChangesResult = {
+    staged: FileChange[];
+    unstaged?: FileChange[];
+    untracked?: FileChange[];
+};
+/**
+ * The 'git status' for coco
+ *
+ * Get paths of changed files in the Git repository, excluding ignored files and extensions.
+ *
+ * @param {string[]} [options.ignoredFiles] - An optional array of file patterns to ignore.
+ *    If not provided, it defaults to the `ignoredFiles` configuration value from the app's config.
+ * @param {string[]} [options.ignoredExtensions] - An optional array of file extensions to ignore.
+ *   If not provided, it defaults to the `ignoredExtensions` configuration value from the app's config.
+ * @returns {Promise<GetChangesResult>} A Promise that resolves to an array of changed file paths.
+ *
+ * @example
+ * const changes = await getStagedChanges()
+ * console.log(changes)
+ * // {
+ * //   staged: [
+ * //     {
+ * //       filepath: 'src/index.ts',
+ * //       action: 'modified'
+ * //     },
+ * //   ],
+ * //   unstaged: [
+ * //     {
+ * //       filepath: 'src/index.test.ts',
+ * //       action: 'added'
+ * //     }
+ * //   ]
+ * // }
+ */
+export declare function getChanges(repo: Repository, options?: GetChangesArgs): Promise<GetChangesResult>;

package/dist/lib/utils/git/getStatus.d.ts

@@ -0,0 +1,3 @@
+import { ConvenientPatch } from "nodegit";
+import { FileChangeStatus } from "../../types";
+export declare const getStatus: (patch: ConvenientPatch) => FileChangeStatus;

package/dist/lib/utils/git/getSummaryText.d.ts

@@ -0,0 +1,2 @@
+import { ConvenientPatch } from 'nodegit';
+export declare const getSummaryText: (patch: ConvenientPatch) => string;

package/dist/lib/utils/git/parsePatches.d.ts

@@ -0,0 +1,18 @@
+import { ConvenientPatch } from 'nodegit';
+import { FileChange } from '../../types';
+type ParsePatchesOptions = {
+    ignoredFiles?: string[];
+    ignoredExtensions?: string[];
+};
+/**
+ * Parse patches from a git diff.
+ *
+ * @param {ConvenientPatch[]} patches - An array of git patches.
+ * @param {string[]} [options.ignoredFiles] - An optional array of file patterns to ignore.
+ *   If not provided, it defaults to the `ignoredFiles` configuration value from the app's config.
+ * @param {string[]} [options.ignoredExtensions] - An optional array of file extensions to ignore.
+ *  If not provided, it defaults to the `ignoredExtensions` configuration value from the app's config.
+ * @returns {Promise<FileChange[]>} A Promise that resolves to an array of file changes.
+ **/
+export declare const parsePatches: (patches: ConvenientPatch[], { ignoredFiles, ignoredExtensions, }: ParsePatchesOptions) => Promise<FileChange[]>;
+export {};

package/dist/lib/utils/logger.d.ts

@@ -0,0 +1,23 @@
+import { type Color } from 'chalk';
+export interface LoggerOptions {
+    color?: typeof Color;
+}
+export interface SpinnerOptions {
+    mode?: undefined | 'stop' | 'succeed' | 'warn' | 'fail';
+    color?: typeof Color;
+}
+export interface Config {
+    verbose?: boolean;
+}
+export declare class Logger {
+    private config;
+    private timerStart;
+    private spinner;
+    constructor(config: Config);
+    log(message: string, options?: LoggerOptions): Logger;
+    verbose(message: string, options?: LoggerOptions): Logger;
+    startTimer(): Logger;
+    stopTimer(message?: string, options?: LoggerOptions): Logger;
+    startSpinner(message: string, options?: Omit<SpinnerOptions, 'mode'>): Logger;
+    stopSpinner(message?: string | undefined, options?: SpinnerOptions): Logger;
+}

package/dist/lib/utils/readFile.d.ts

@@ -0,0 +1,3 @@
+/// <reference types="node" />
+import * as fs from 'fs';
+export declare const readFile: typeof fs.readFile.__promisify__;

package/dist/lib/utils/removeUndefined.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Returns a new object with all undefined keys removed
+ *
+ * @param obj Object to remove undefined keys from
+ * @returns
+ */
+export declare function removeUndefined(obj: Record<string, unknown>): {
+    [k: string]: unknown;
+};