cloving 0.3.18 → 0.3.19

package/src/utils/types.ts

@@ -0,0 +1,127 @@
+export type GPTProvider = 'openai' | 'claude' | 'ollama' | 'gemini'
+
+export interface BlockIndices {
+  start: number
+  current: number
+  filePathEnd: number
+  divider: number
+  end: number
+}
+
+export interface OpenAIStreamChunk {
+  output: string
+  lastChar: number
+}
+
+export interface CurrentNewBlock {
+  language: string
+  filePath: string
+  currentContent: string
+  newContent: string
+}
+
+export interface ChatMessage {
+  role: 'user' | 'assistant' | 'system'
+  content: string
+}
+
+export interface GPTRequest {
+  messages?: ChatMessage[]
+  prompt: string
+  maxTokens?: number
+  temperature?: number
+  stream?: boolean
+}
+
+export interface ClovingGPTOptions {
+  model?: string
+  silent?: boolean
+  files?: string[]
+  prompt?: string
+  save?: boolean
+  exec?: boolean
+  interactive?: boolean
+  temperature?: number
+  port?: number
+  stream?: boolean
+  timeout?: number
+}
+
+export interface ClovingModelConfig {
+  apiKey: string
+  primary: boolean
+  priority: number
+  silent: boolean
+  trust: boolean
+  temperature: number
+  endpoint?: string
+}
+
+export type ProjectConfig = {
+  name: string
+  task: string
+  files?: string[]
+  plan?: Record<string, any>
+}
+
+export type ClovingConfig = {
+  models: {
+    [provider: string]: {
+      [model: string]: ClovingModelConfig
+    }
+  }
+  globalSilent: boolean
+}
+
+interface LanguageConfig {
+  name: string
+  version?: string
+  primary?: boolean
+  directory: string
+  extension: string
+}
+
+interface FrameworkConfig {
+  name: string
+  type: string
+  version?: string
+  primary?: boolean
+  directory?: string
+  extension?: string
+}
+
+interface TestingFrameworkConfig {
+  name: string
+  type: string
+  version?: string
+  directory?: string
+  runCommand?: string
+}
+
+interface BuildToolConfig {
+  name: string
+  type: string
+  version?: string
+}
+
+interface LinterConfig {
+  name: string
+  version?: string
+  type?: string
+}
+
+interface DatabaseConfig {
+  name: string
+  primary?: boolean
+}
+
+export interface ClovingfileConfig {
+  languages: LanguageConfig[]
+  frameworks: FrameworkConfig[]
+  testingFrameworks?: TestingFrameworkConfig[]
+  buildTools: BuildToolConfig[]
+  packageManager: string
+  linters: LinterConfig[]
+  databases?: DatabaseConfig[]
+  projectType: string
+}

package/tests/commands/generate/unit_tests.test.ts

@@ -0,0 +1,27 @@
+import unitTests from '../../../src/commands/generate/unit_tests';
+import ClovingGPT from '../../../src/cloving_gpt';
+
+jest.mock('../../../src/utils/git_utils', () => ({
+  getGitDiff: jest.fn(),
+}));
+
+jest.mock('../../../src/cloving_gpt');
+
+describe('unitTests', () => {
+  const mockOptions = { files: ['src/cloving_gpt/adapters/ollama.ts'], silent: true, save: true };
+  const mockGenerateText = jest.fn();
+  const gpt = new ClovingGPT(mockOptions);
+
+  beforeEach(() => {
+    (ClovingGPT as jest.Mock).mockImplementation(() => ({
+      generateText: mockGenerateText,
+    }));
+    jest.clearAllMocks();
+  });
+
+  test('should generate unit tests for provided files', async () => {
+    mockGenerateText.mockResolvedValueOnce('Generated unit tests content');
+    await unitTests(mockOptions);
+    expect(mockGenerateText).toHaveBeenCalled();
+  });
+});

package/tests/utils/git_utils.test.ts

@@ -0,0 +1,116 @@
+import {
+  getGitDiff,
+  getDefaultBranchName,
+  getCurrentBranchName,
+  findCommitlintConfig,
+  generateCommitMessagePrompt,
+  readCommitlintConfig,
+} from '../../src/utils/git_utils'
+import { execSync } from 'child_process'
+import fs from 'fs'
+import path from 'path'
+
+jest.mock('child_process', () => ({
+  execSync: jest.fn(),
+}))
+
+jest.mock('fs', () => ({
+  existsSync: jest.fn(),
+  readFileSync: jest.fn(),
+}))
+
+describe('gitUtils', () => {
+  beforeEach(() => {
+    jest.clearAllMocks()
+  })
+
+  test('getDefaultBranchName should return the default branch name', async () => {
+    ;(execSync as jest.Mock).mockReturnValueOnce('main\n')
+    const result = await getDefaultBranchName()
+    expect(result).toBe('main')
+  })
+
+  test('getCurrentBranchName should return the current branch name', () => {
+    ;(execSync as jest.Mock).mockReturnValueOnce('feature-branch\n')
+    const result = getCurrentBranchName()
+    expect(result).toBe('feature-branch')
+  })
+
+  describe('commitlint integration', () => {
+    test('findCommitlintConfig should return null when no config file exists', () => {
+      ;(fs.existsSync as jest.Mock).mockReturnValue(false)
+      const result = findCommitlintConfig()
+      expect(result).toBeNull()
+    })
+
+    test('findCommitlintConfig should return the path when a config file exists', () => {
+      ;(fs.existsSync as jest.Mock).mockImplementation(
+        (path: string) => path === '.commitlintrc.json',
+      )
+      const result = findCommitlintConfig()
+      expect(result).toBe('.commitlintrc.json')
+    })
+
+    test('readCommitlintConfig should parse JSON config files', () => {
+      const mockConfig = {
+        extends: ['@commitlint/config-conventional'],
+        rules: {
+          'type-enum': [2, 'always', ['feat', 'fix']],
+        },
+      }
+      ;(fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(mockConfig))
+      const result = readCommitlintConfig('.commitlintrc.json')
+      expect(result).toEqual(mockConfig)
+    })
+
+    test('readCommitlintConfig should handle YAML config files', () => {
+      const mockYamlConfig = `
+extends: ['@commitlint/config-conventional']
+rules:
+  type-enum: [2, 'always', ['feat', 'fix']]
+`
+      ;(fs.readFileSync as jest.Mock).mockReturnValue(mockYamlConfig)
+      const result = readCommitlintConfig('.commitlintrc.yml')
+      expect(result).toEqual({ config: mockYamlConfig })
+    })
+
+    test('readCommitlintConfig should return null for JS/TS config files', () => {
+      const result = readCommitlintConfig('commitlint.config.js')
+      expect(result).toBeNull()
+    })
+
+    describe('generateCommitMessagePrompt', () => {
+      test('should always include conventional commit format instructions', () => {
+        ;(fs.existsSync as jest.Mock).mockReturnValue(false)
+        const diff = 'sample diff'
+        const result = generateCommitMessagePrompt(diff)
+
+        expect(result).toContain('<type>[optional scope]: <description>')
+        expect(result).toContain('Types must be one of:')
+        expect(result).toContain('feat: A new feature')
+        expect(result).toContain('fix: A bug fix')
+      })
+
+      test('should include commitlint config when available', () => {
+        const mockConfig = {
+          extends: ['@commitlint/config-conventional'],
+          rules: {
+            'type-enum': [2, 'always', ['feat', 'fix']],
+          },
+        }
+        ;(fs.existsSync as jest.Mock).mockImplementation(
+          (path: string) => path === '.commitlintrc.json',
+        )
+        ;(fs.readFileSync as jest.Mock).mockReturnValue(JSON.stringify(mockConfig))
+
+        const diff = 'sample diff'
+        const result = generateCommitMessagePrompt(diff)
+
+        expect(result).toContain('Found commitlint configuration at .commitlintrc.json')
+        expect(result).toContain('"extends":')
+        expect(result).toContain('"rules":')
+        expect(result).toContain('<type>[optional scope]: <description>')
+      })
+    })
+  })
+})

package/tests/utils/model_utils.test.ts

@@ -0,0 +1,27 @@
+
+import { getModel } from '../../src/utils/model_utils'
+
+describe('modelUtils', () => {
+  const originalEnv = process.env
+
+  beforeEach(() => {
+    jest.resetModules()
+    process.env = { ...originalEnv }
+  })
+
+  afterAll(() => {
+    process.env = originalEnv
+  })
+
+  test('getModel should return default model when CLOVING_MODEL is not set', () => {
+    delete process.env.CLOVING_MODEL
+    const result = getModel()
+    expect(result).toBe('claude:claude-3-5-sonnet-20240620')
+  })
+
+  test('getModel should return CLOVING_MODEL when it is set', () => {
+    process.env.CLOVING_MODEL = 'openai:gpt-4'
+    const result = getModel()
+    expect(result).toBe('openai:gpt-4')
+  })
+})

package/tests/utils/prompt_utils.test.ts

@@ -0,0 +1,33 @@
+import { generateCodegenPrompt } from '../../src/utils/prompt_utils'
+import { CODEGEN_INSTRUCTIONS } from '../../src/utils/prompts'
+
+jest.mock('../../src/utils/config_utils', () => ({
+  getClovingConfig: jest.fn().mockReturnValue({}),
+  getNearestClovingConfig: jest.fn().mockReturnValue({ config: {}, path: '' }),
+}))
+
+describe('prompt_utils', () => {
+  describe('CODEGEN_INSTRUCTIONS', () => {
+    it('should contain the correct instructions', () => {
+      expect(CODEGEN_INSTRUCTIONS).toContain('AI Code Generation Instructions')
+      expect(CODEGEN_INSTRUCTIONS).toContain('General Guidelines')
+      expect(CODEGEN_INSTRUCTIONS).toContain('Request Handling')
+      expect(CODEGEN_INSTRUCTIONS).toContain('*CURRENT/NEW* Block Format')
+    })
+  })
+
+  describe('generateCodegenPrompt', () => {
+    it('should include CODEGEN_INSTRUCTIONS in the generated prompt', () => {
+      const contextFilesContent = { 'test.ts': 'console.log("test");' }
+      const result = generateCodegenPrompt(contextFilesContent)
+      expect(result).toContain(CODEGEN_INSTRUCTIONS)
+    })
+
+    it('should include context files content in the generated prompt', () => {
+      const contextFilesContent = { 'test.ts': 'console.log("test");' }
+      const result = generateCodegenPrompt(contextFilesContent)
+      expect(result).toContain('test.ts')
+      expect(result).toContain('console.log("test");')
+    })
+  })
+})