cloving 0.3.18 → 0.3.19

package/src/utils/config_utils.ts

@@ -0,0 +1,271 @@
+/**
+ * @file Configuration utilities for Cloving
+ * @module config_utils
+ */
+
+import os from 'os'
+import path from 'path'
+import fs from 'fs'
+import ini from 'ini'
+import { execFileSync } from 'child_process'
+
+import ClovingGPT from '../cloving_gpt'
+import type {
+  ClovingConfig,
+  ClovingGPTOptions,
+  ClovingModelConfig,
+  ClovingfileConfig,
+  ProjectConfig,
+} from '../utils/types'
+
+/** Path to the global Cloving configuration file */
+export const CLOVING_CONFIG_PATH = path.join(os.homedir(), '.clovingconfig')
+/** Name of the local Cloving configuration file */
+export const CLOVINGFILE_PATH = 'cloving.json'
+/** Path to the Cloving projects directory */
+export const CLOVINGPROJECT_PATH = '.clovingprojects'
+
+/** Cached Cloving configuration */
+let clovingConfig: ClovingfileConfig
+
+/**
+ * Retrieves the Cloving configuration
+ * @param {ClovingGPTOptions} options - Options for ClovingGPT
+ * @returns {ClovingConfig} The Cloving configuration
+ */
+export const getConfig = (options: ClovingGPTOptions): ClovingConfig => {
+  try {
+    if (fs.existsSync(CLOVING_CONFIG_PATH)) {
+      const rawConfig = fs.readFileSync(CLOVING_CONFIG_PATH, 'utf-8')
+      const config = ini.parse(rawConfig) as ClovingConfig
+      if (options.silent) {
+        config.globalSilent = true
+      }
+
+      // Parse temperature to float if it exists in the config
+      for (const provider in config.models) {
+        for (const model in config.models[provider]) {
+          if (config.models[provider][model].temperature !== undefined) {
+            const temp = config.models[provider][model].temperature
+            config.models[provider][model].temperature =
+              typeof temp === 'string' ? parseFloat(temp) : temp
+          }
+        }
+      }
+
+      return config
+    }
+  } catch (err) {
+    console.error('Error reading configuration:', err)
+  }
+
+  // Fallback to environment variables if config file doesn't exist
+  if (process.env.CLOVING_MODEL) {
+    const [provider, ...modelParts] = process.env.CLOVING_MODEL.split(':')
+    const model = modelParts.join(':')
+    return {
+      models: {
+        [provider]: {
+          [model]: {
+            apiKey: process.env.CLOVING_API_KEY ?? '',
+            primary: true,
+            priority: 10,
+            silent: options.silent || false,
+            trust: false,
+            temperature: options.temperature || 0.2,
+          },
+        },
+      },
+      globalSilent: options.silent || false,
+    }
+  } else {
+    return { models: {}, globalSilent: options.silent || false }
+  }
+}
+
+/**
+ * Retrieves the local Cloving configuration
+ * @returns {ClovingfileConfig} The local Cloving configuration
+ * @throws {Error} If the cloving.json file is not found
+ */
+export const getClovingConfig = (): ClovingfileConfig => {
+  if (clovingConfig) {
+    return clovingConfig
+  } else if (fs.existsSync(CLOVINGFILE_PATH)) {
+    clovingConfig = getClovingConfigAtPath(CLOVINGFILE_PATH)
+    return clovingConfig
+  } else {
+    console.log(`${CLOVINGFILE_PATH} file not found, please run: cloving init`)
+    process.exit(1)
+  }
+}
+
+const getClovingConfigAtPath = (fullPath: string): ClovingfileConfig => {
+  const configFile = fs.readFileSync(fullPath, 'utf-8')
+  return JSON.parse(configFile) as ClovingfileConfig
+}
+
+export const getNearestClovingConfig = (): { config: ClovingfileConfig; path: string } => {
+  let runPath = process.cwd()
+  const parts = runPath.split(path.sep)
+  while (parts.length > 0) {
+    const configPath = path.join(parts.join(path.sep), CLOVINGFILE_PATH)
+    if (fs.existsSync(configPath)) {
+      clovingConfig = getClovingConfigAtPath(configPath)
+      return { config: clovingConfig, path: configPath }
+    }
+    parts.pop()
+  }
+  throw new Error(`No ${CLOVINGFILE_PATH} file found in ${runPath} or any parent directory`)
+}
+
+/**
+ * Saves the Cloving configuration to the config file
+ * @param {ClovingConfig} config - The configuration to save
+ */
+export const saveConfig = (config: ClovingConfig): void => {
+  const iniString = ini.stringify(config)
+  fs.writeFileSync(CLOVING_CONFIG_PATH, iniString)
+  console.log(`Configuration saved to ${CLOVING_CONFIG_PATH}`)
+}
+
+/**
+ * Retrieves the primary model configuration
+ * @param {string} [partialModel] - Partial model name to filter by
+ * @returns {Object | null} The primary model configuration or null if not found
+ */
+export const getPrimaryModel = (
+  partialModel?: string,
+): { provider: string; model: string; config: ClovingModelConfig } | null => {
+  try {
+    const config = getConfig({})
+    const models: { provider: string; model: string; config: ClovingModelConfig }[] = []
+
+    for (const provider in config.models) {
+      for (const model in config.models[provider]) {
+        if (!partialModel || `${provider}:${model}`.startsWith(partialModel)) {
+          models.push({
+            provider,
+            model,
+            config: config.models[provider][model],
+          })
+        }
+      }
+    }
+
+    models.sort(
+      (a, b) => parseInt(`${b.config.priority}`, 10) - parseInt(`${a.config.priority}`, 10),
+    )
+
+    return models.length > 0 ? models[0] : null
+  } catch (err) {
+    console.error('Error reading model from configuration:', err)
+    return null
+  }
+}
+
+/**
+ * Retrieves the configuration for a specific project
+ * @param {string} name - The name of the project
+ * @returns {ProjectConfig} The project configuration
+ * @throws {Error} If the project configuration file is not found
+ */
+export const getProjectConfig = (name: string): ProjectConfig => {
+  const projectConfigPath = path.join(CLOVINGPROJECT_PATH, name, 'config.ini')
+  if (fs.existsSync(projectConfigPath)) {
+    const configFile = fs.readFileSync(projectConfigPath, 'utf-8')
+    return ini.parse(configFile) as ProjectConfig
+  } else {
+    throw new Error(`${projectConfigPath} file not found`)
+  }
+}
+
+/**
+ * Saves the configuration for a specific project
+ * @param {string} name - The name of the project
+ * @param {ProjectConfig} config - The project configuration to save
+ */
+export const saveProjectConfig = (name: string, config: ProjectConfig): void => {
+  const projectConfigPath = path.join(CLOVINGPROJECT_PATH, name, 'config.ini')
+  const projectConfigDir = path.dirname(projectConfigPath)
+
+  // Create directory if it doesn't exist
+  if (!fs.existsSync(projectConfigDir)) {
+    fs.mkdirSync(projectConfigDir, { recursive: true })
+  }
+
+  const iniString = ini.stringify(config)
+  fs.writeFileSync(projectConfigPath, iniString)
+  console.log(`Configuration saved to ${projectConfigPath}`)
+}
+
+/**
+ * Removes the configuration file for a specific project
+ * @param {string} name - The name of the project
+ */
+export const removeProjectConfig = (name: string): void => {
+  const projectConfigPath = path.join(CLOVINGPROJECT_PATH, name, 'config.ini')
+  if (fs.existsSync(projectConfigPath)) {
+    fs.unlinkSync(projectConfigPath)
+    console.log(`Project completed and file removed: ${projectConfigPath}`)
+  } else {
+    console.error(`Configuration not found: ${projectConfigPath}`)
+  }
+}
+
+const setupTestingPrompt = async (gpt: ClovingGPT, config: ClovingfileConfig) => {
+  const prompt = `I have the following cloving.json configuration file:
+
+==== begin cloving.json ====
+${JSON.stringify(config, null, 2)}
+==== end cloving.json ====
+
+Please provide instructions on how to set up testing for this project.`
+
+  const setupInstructions = await gpt.generateText({ prompt })
+
+  console.log(setupInstructions)
+  process.exit(0)
+}
+
+export const getAllFiles = async (
+  options: ClovingGPTOptions,
+  forTesting: boolean,
+): Promise<string[]> => {
+  const gpt = new ClovingGPT(options)
+
+  // Read the cloving.json file
+  const { config } = getNearestClovingConfig()
+  const testingDirectory = getTestingDirectory()
+
+  let allSrcFiles: string[] = []
+
+  if (forTesting && !testingDirectory) {
+    await setupTestingPrompt(gpt, config)
+  }
+
+  // Collect srcFiles for each language with specified directory and extension
+  for (const language of config.languages) {
+    if (language.directory && language.extension) {
+      const srcFiles = execFileSync('find', [
+        language.directory,
+        '-type',
+        'f',
+        '-name',
+        `*${language.extension}`,
+      ])
+        .toString()
+        .trim()
+        .split('\n')
+      allSrcFiles = allSrcFiles.concat(srcFiles)
+    }
+  }
+
+  // Ensure allSrcFiles is unique
+  return Array.from(new Set(allSrcFiles))
+}
+
+export const getTestingDirectory = (): string | undefined => {
+  const config = getClovingConfig()
+  return config.testingFrameworks?.find((framework: any) => framework.directory)?.directory
+}

package/src/utils/git_utils.ts

@@ -0,0 +1,230 @@
+/**
+ * @module git_utils
+ * @description Provides utility functions for Git operations and commit message generation.
+ */
+
+import { execSync } from 'child_process'
+import readline from 'readline'
+import fs from 'fs'
+import path from 'path'
+
+const COMMITLINT_CONFIG_FILES = [
+  '.commitlintrc',
+  '.commitlintrc.json',
+  '.commitlintrc.yaml',
+  '.commitlintrc.yml',
+  '.commitlintrc.js',
+  '.commitlintrc.cjs',
+  '.commitlintrc.mjs',
+  '.commitlintrc.ts',
+  '.commitlintrc.cts',
+  'commitlint.config.js',
+  'commitlint.config.cjs',
+  'commitlint.config.mjs',
+  'commitlint.config.ts',
+  'commitlint.config.cts',
+]
+
+/**
+ * Prompts the user with a question and returns their answer.
+ * @param {string} question - The question to ask the user.
+ * @returns {Promise<string>} A promise that resolves with the user's answer.
+ */
+const askQuestion = (question: string): Promise<string> => {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout,
+  })
+
+  return new Promise((resolve) =>
+    rl.question(question, (answer) => {
+      rl.close()
+      resolve(answer)
+    }),
+  )
+}
+
+/**
+ * Retrieves the Git diff between the current branch and the default branch.
+ * @returns {Promise<string>} A promise that resolves with the indented Git diff.
+ * @throws {Error} If there's an error getting the Git diff.
+ */
+export const getGitDiff = async (): Promise<string> => {
+  try {
+    const defaultBranchName = await getDefaultBranchName()
+
+    const gitDiff = execSync(`git diff ${defaultBranchName} --`).toString().trim()
+
+    // Indent each line by four spaces
+    const indentedDiff = gitDiff
+      .split('\n')
+      .map((line) => `    ${line}`)
+      .join('\n')
+
+    return indentedDiff
+  } catch (error) {
+    console.error('Error getting git diff:', (error as Error).message)
+    process.exit(1)
+  }
+}
+
+/**
+ * Determines the default branch name for the Git repository.
+ * @returns {Promise<string>} A promise that resolves with the default branch name.
+ * @throws {Error} If the default branch cannot be determined.
+ */
+export const getDefaultBranchName = async (): Promise<string> => {
+  let defaultBranchName = execSync(
+    "git symbolic-ref refs/remotes/origin/HEAD | sed 's@^refs/remotes/origin/@@'",
+  )
+    .toString()
+    .trim()
+
+  if (defaultBranchName === '') {
+    console.error('Could not determine the default branch.')
+
+    const answer = await askQuestion('Do you want to run `git remote set-head origin -a`? [Y/n] ')
+
+    if (answer.toLowerCase() === 'y' || answer === '') {
+      execSync('git remote set-head origin -a')
+      defaultBranchName = await getDefaultBranchName()
+
+      if (defaultBranchName === '') {
+        throw new Error('Error: Could not determine the default branch (main or master)')
+      }
+    } else {
+      throw new Error('Operation aborted by user.')
+    }
+  }
+
+  return defaultBranchName
+}
+
+/**
+ * Retrieves the name of the current Git branch.
+ * @returns {string} The name of the current Git branch.
+ * @throws {Error} If there's an error getting the current branch name.
+ */
+export const getCurrentBranchName = (): string => {
+  try {
+    return execSync('git rev-parse --abbrev-ref HEAD').toString().trim()
+  } catch (error) {
+    console.error('Error getting current branch name:', (error as Error).message)
+    process.exit(1)
+  }
+}
+
+/**
+ * Checks if a commitlint configuration file exists in the project.
+ * @returns {string | null} The path to the commitlint config file if found, null otherwise.
+ */
+export const findCommitlintConfig = (): string | null => {
+  for (const configFile of COMMITLINT_CONFIG_FILES) {
+    if (fs.existsSync(configFile)) {
+      return configFile
+    }
+  }
+  return null
+}
+
+/**
+ * Reads and parses the commitlint configuration file.
+ * @param {string} configPath - Path to the commitlint config file.
+ * @returns {object | null} The parsed configuration object or null if unable to parse.
+ */
+export const readCommitlintConfig = (configPath: string): object | null => {
+  try {
+    const ext = path.extname(configPath)
+
+    if (['.js', '.cjs', '.mjs', '.ts', '.cts'].includes(ext)) {
+      // For JavaScript/TypeScript config files, we can't safely require them
+      // as they might have dependencies or complex configurations
+      return null
+    }
+
+    if (['.json', '', '.yaml', '.yml'].includes(ext)) {
+      const content = fs.readFileSync(configPath, 'utf-8')
+
+      if (ext === '.json' || ext === '') {
+        return JSON.parse(content)
+      }
+
+      // For YAML files, we'll just return the raw content as a string
+      return { config: content }
+    }
+
+    return null
+  } catch (error) {
+    console.error('Error reading commitlint config:', (error as Error).message)
+    return null
+  }
+}
+
+/**
+ * Generates a prompt for creating a commit message based on a Git diff.
+ * @param {string} diff - The Git diff to base the commit message on.
+ * @returns {string} A prompt string for generating a commit message.
+ */
+export const generateCommitMessagePrompt = (diff: string): string => {
+  // Check if commitlint is configured
+  const commitlintConfig = findCommitlintConfig()
+  let configInfo = ''
+
+  if (commitlintConfig) {
+    const config = readCommitlintConfig(commitlintConfig)
+    if (config) {
+      configInfo = `\nFound commitlint configuration at ${commitlintConfig}:
+\`\`\`json
+${JSON.stringify(config, null, 2)}
+\`\`\`
+Please ensure the commit message follows any additional rules specified in this configuration.
+`
+    }
+  }
+
+  return `Generate a conventional commit message following the Conventional Commits specification (www.conventionalcommits.org).${configInfo}
+
+The commit message should follow this format:
+<type>[optional scope]: <description>
+
+[optional body]
+
+[optional footer(s)]
+
+Types must be one of:
+1. revert: Reverts a previous commit
+2. feat: A new feature
+3. fix: A bug fix
+4. refactor: A code change that neither fixes a bug nor adds a feature
+5. perf: A code change that improves performance
+6. build: Changes that affect the build system or external dependencies or updates to versions of dependencies or version bumps
+7. test: Adding missing tests or correcting existing tests
+8. docs: Documentation only changes
+9. style: Changes that do not affect the meaning of the code
+10. ci: Changes to our CI configuration files and scripts
+11. chore: Other changes that don't modify src or test files
+
+Use the order of types as an order of precedence for the commit message if there are multiple types in one commit.
+
+The scope should be the part of the codebase affected.
+The description should be imperative, present tense, and not capitalized.
+Breaking changes should be indicated by "!" before the ":" or by "BREAKING CHANGE:" in the footer.
+
+Do not add any commentary or context to the message other than the commit message itself.
+
+Here is an example of a valid conventional commit message:
+
+\`\`\`plaintext
+feat(api): add new endpoint for user authentication
+
+- Implement JWT token generation
+- Add password hashing with bcrypt
+- Create user validation middleware
+
+BREAKING CHANGE: 'auth' endpoint now requires API key in headers
+\`\`\`
+
+Here is the diff to help you write the commit message:
+
+${diff}`
+}

package/src/utils/model_utils.ts

@@ -0,0 +1,3 @@
+export const getModel = (): string => {
+  return process.env.CLOVING_MODEL || 'claude:claude-3-5-sonnet-20240620'
+}