recoder-code 1.0.113

package/tests/auto-close-duplicates.test.ts

@@ -0,0 +1,145 @@
+import { autoCloseDuplicates } from '../api/githubApi';
+import { Octokit } from '@octokit/rest';
+import { expect, describe, it, vi } from 'vitest';
+
+vi.mock('@octokit/rest', () => {
+  return {
+    Octokit: vi.fn().mockImplementation(() => ({
+      issues: {
+        listForRepo: vi.fn(),
+        createComment: vi.fn(),
+        update: vi.fn(),
+      },
+    })),
+  };
+});
+
+vi.mock('openai', async () => {
+  const actual = await vi.importActual('openai');
+  return {
+    ...actual,
+    default: class MockOpenAI {
+      constructor() {}
+    },
+  };
+});
+
+describe('autoCloseDuplicates', () => {
+  it('should close duplicate issues', async () => {
+    const mockOctokit = new Octokit();
+    const listForRepo = mockOctokit.issues.listForRepo as unknown as ReturnType<typeof vi.fn>;
+    const createComment = mockOctokit.issues.createComment as unknown as ReturnType<typeof vi.fn>;
+    const update = mockOctokit.issues.update as unknown as ReturnType<typeof vi.fn>;
+    listForRepo.mockResolvedValue({
+      data: [
+        { number: 1, title: 'Duplicate Issue' },
+        { number: 2, title: 'Duplicate Issue' },
+        { number: 3, title: 'Unique Issue' },
+      ],
+    });
+
+    await autoCloseDuplicates();
+
+    expect(listForRepo).toHaveBeenCalledWith({
+      owner: process.env.GITHUB_OWNER,
+      repo: process.env.GITHUB_REPO,
+      state: 'open',
+    });
+
+    expect(createComment).toHaveBeenCalledWith({
+      owner: process.env.GITHUB_OWNER,
+      repo: process.env.GITHUB_REPO,
+      issue_number: 2,
+      body: 'Closing as duplicate of #1',
+    });
+
+    expect(update).toHaveBeenCalledWith({
+      owner: process.env.GITHUB_OWNER,
+      repo: process.env.GITHUB_REPO,
+      issue_number: 2,
+      state: 'closed',
+    });
+  });
+
+  it('should not close issues if no duplicates are found', async () => {
+    const mockOctokit = new Octokit();
+    const listForRepo = mockOctokit.issues.listForRepo as unknown as ReturnType<typeof vi.fn>;
+    const createComment = mockOctokit.issues.createComment as unknown as ReturnType<typeof vi.fn>;
+    const update = mockOctokit.issues.update as unknown as ReturnType<typeof vi.fn>;
+    listForRepo.mockResolvedValue({
+      data: [
+        { number: 1, title: 'Unique Issue 1' },
+        { number: 2, title: 'Unique Issue 2' },
+        { number: 3, title: 'Unique Issue 3' },
+      ],
+    });
+
+    await autoCloseDuplicates();
+
+    expect(listForRepo).toHaveBeenCalledWith({
+      owner: process.env.GITHUB_OWNER,
+      repo: process.env.GITHUB_REPO,
+      state: 'open',
+    });
+
+    expect(createComment).not.toHaveBeenCalled();
+    expect(update).not.toHaveBeenCalled();
+  });
+
+  it('should handle errors when fetching issues', async () => {
+    const mockOctokit = new Octokit();
+    const listForRepo = mockOctokit.issues.listForRepo as unknown as ReturnType<typeof vi.fn>;
+    const createComment = mockOctokit.issues.createComment as unknown as ReturnType<typeof vi.fn>;
+    const update = mockOctokit.issues.update as unknown as ReturnType<typeof vi.fn>;
+    listForRepo.mockRejectedValue(new Error('Failed to fetch issues'));
+
+    await autoCloseDuplicates();
+
+    expect(listForRepo).toHaveBeenCalledWith({
+      owner: process.env.GITHUB_OWNER,
+      repo: process.env.GITHUB_REPO,
+      state: 'open',
+    });
+
+    expect(createComment).not.toHaveBeenCalled();
+    expect(update).not.toHaveBeenCalled();
+  });
+
+  it('should handle errors when closing issues', async () => {
+    const mockOctokit = new Octokit();
+    const listForRepo = mockOctokit.issues.listForRepo as unknown as ReturnType<typeof vi.fn>;
+    const createComment = mockOctokit.issues.createComment as unknown as ReturnType<typeof vi.fn>;
+    const update = mockOctokit.issues.update as unknown as ReturnType<typeof vi.fn>;
+    listForRepo.mockResolvedValue({
+      data: [
+        { number: 1, title: 'Duplicate Issue' },
+        { number: 2, title: 'Duplicate Issue' },
+        { number: 3, title: 'Unique Issue' },
+      ],
+    });
+    createComment.mockRejectedValue(new Error('Failed to create comment'));
+    update.mockRejectedValue(new Error('Failed to update issue'));
+
+    await autoCloseDuplicates();
+
+    expect(listForRepo).toHaveBeenCalledWith({
+      owner: process.env.GITHUB_OWNER,
+      repo: process.env.GITHUB_REPO,
+      state: 'open',
+    });
+
+    expect(createComment).toHaveBeenCalledWith({
+      owner: process.env.GITHUB_OWNER,
+      repo: process.env.GITHUB_REPO,
+      issue_number: 2,
+      body: 'Closing as duplicate of #1',
+    });
+
+    expect(update).toHaveBeenCalledWith({
+      owner: process.env.GITHUB_OWNER,
+      repo: process.env.GITHUB_REPO,
+      issue_number: 2,
+      state: 'closed',
+    });
+  });
+});

package/tests/cli-configure.test.ts

@@ -0,0 +1,88 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+const configPath = path.join(__dirname, '..', '.recoderrc');
+
+beforeEach(() => {
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify({}), 'utf8');
+});
+
+afterEach(() => {
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+  }
+});
+
+describe('CLI Configure Command', () => {
+  it('should set the Open Router API key and model in .recoderrc', () => {
+    const mockApiKey = 'dummy-key';
+    const mockModel = 'gpt-3.5-turbo';
+    execSync(`npx recoder-code configure --key ${mockApiKey} --model ${mockModel}`, { encoding: 'utf8' });
+
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    expect(config.openRouterApiKey).toBe(mockApiKey);
+    expect(config.openRouterModel).toBe(mockModel);
+  });
+
+  it('should create .recoderrc if it does not exist', () => {
+    const mockApiKey = 'dummy-key';
+    const mockModel = 'gpt-3.5-turbo';
+    execSync(`npx recoder-code configure --key ${mockApiKey} --model ${mockModel}`, { encoding: 'utf8' });
+
+    expect(fs.existsSync(configPath)).toBe(true);
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    expect(config.openRouterApiKey).toBe(mockApiKey);
+    expect(config.openRouterModel).toBe(mockModel);
+  });
+
+  it('should handle missing key argument gracefully', () => {
+    const mockModel = 'gpt-3.5-turbo';
+    try {
+      execSync(`npx recoder-code configure --model ${mockModel}`, { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Please provide an API key.');
+      }
+    }
+  });
+
+  it('should handle missing model argument gracefully', () => {
+    const mockApiKey = 'dummy-key';
+    try {
+      execSync(`npx recoder-code configure --key ${mockApiKey}`, { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Please provide a model.');
+      }
+    }
+  });
+
+  it('should validate the API key format', () => {
+    const invalidApiKey = 'invalid-key';
+    const mockModel = 'gpt-3.5-turbo';
+    try {
+      execSync(`npx recoder-code configure --key ${invalidApiKey} --model ${mockModel}`, { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Invalid Open Router API key format');
+      }
+    }
+  });
+
+  it('should validate the model format', () => {
+    const mockApiKey = 'dummy-key';
+    const invalidModel = 'invalid-model';
+    try {
+      execSync(`npx recoder-code configure --key ${mockApiKey} --model ${invalidModel}`, { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Invalid Open Router model format');
+      }
+    }
+  });
+});

package/tests/cli-list-models.test.ts

@@ -0,0 +1,44 @@
+import { execSync } from 'child_process';
+import axios from 'axios';
+import { mocked } from 'jest-mock';
+
+jest.mock('axios');
+
+describe('CLI List Models Command', () => {
+  it('should list available models successfully', () => {
+    const mockModels = [
+      { id: 'gpt-3.5-turbo', name: 'GPT-3.5 Turbo' },
+      { id: 'gpt-4', name: 'GPT-4' }
+    ];
+    (axios.get as jest.Mock).mockResolvedValue({ data: mockModels });
+
+    const result = execSync('npx recoder-code list-models', { encoding: 'utf8' });
+    expect(result).toContain('Available models:');
+    expect(result).toContain('gpt-3.5-turbo');
+    expect(result).toContain('gpt-4');
+  });
+
+  it('should handle network errors gracefully', () => {
+    (axios.get as jest.Mock).mockRejectedValue(new Error('Network Error'));
+
+    try {
+      execSync('npx recoder-code list-models', { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Error fetching models: Network Error');
+      }
+    }
+  });
+
+  it('should handle API errors gracefully', () => {
+    (axios.get as jest.Mock).mockResolvedValue({ data: { error: 'API Error' } });
+
+    try {
+      execSync('npx recoder-code list-models', { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Error fetching models: API Error');
+      }
+    }
+  });
+});

package/tests/cli-run.test.ts

@@ -0,0 +1,97 @@
+import { execSync } from 'child_process';
+import fs from 'fs';
+import path from 'path';
+import axios from 'axios';
+import { mocked } from 'jest-mock';
+
+jest.mock('axios');
+
+describe('CLI Run Command', () => {
+  const configPath = path.join(process.cwd(), '.recoderrc');
+  const mockConfig = { openRouterApiKey: 'dummy-key', openRouterModel: 'gpt-3.5-turbo' };
+
+  beforeEach(() => {
+    if (fs.existsSync(configPath)) {
+      fs.renameSync(configPath, `${configPath}.bak`);
+    }
+    fs.writeFileSync(configPath, JSON.stringify(mockConfig), 'utf8');
+  });
+
+  afterEach(() => {
+    fs.unlinkSync(configPath);
+    if (fs.existsSync(`${configPath}.bak`)) {
+      fs.renameSync(`${configPath}.bak`, configPath);
+    }
+  });
+
+  it('should run a prompt successfully', () => {
+    const mockResponse = { response: 'Hello, world!' };
+    (axios.post as jest.Mock).mockResolvedValue({ data: mockResponse });
+
+    const result = execSync('npx recoder-code run --prompt "Hello"', { encoding: 'utf8' });
+    expect(result).toContain('Hello, world!');
+  });
+
+  it('should handle missing API key gracefully', () => {
+    fs.unlinkSync(configPath);
+
+    try {
+      execSync('npx recoder-code run --prompt "Hello"', { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Open Router API key not found');
+      }
+    }
+  });
+
+  it('should handle invalid API keys gracefully', () => {
+    const mockConfig = { openRouterApiKey: 'invalid-key', openRouterModel: 'gpt-3.5-turbo' };
+    fs.writeFileSync(configPath, JSON.stringify(mockConfig), 'utf8');
+
+    try {
+      execSync('npx recoder-code run --prompt "Hello"', { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Invalid Open Router API key');
+      }
+    }
+  });
+
+  it('should handle missing model gracefully', () => {
+    const mockConfig = { openRouterApiKey: 'dummy-key' };
+    fs.writeFileSync(configPath, JSON.stringify(mockConfig), 'utf8');
+
+    try {
+      execSync('npx recoder-code run --prompt "Hello"', { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Open Router model not found');
+      }
+    }
+  });
+
+  it('should handle invalid models gracefully', () => {
+    const mockConfig = { openRouterApiKey: 'dummy-key', openRouterModel: 'invalid-model' };
+    fs.writeFileSync(configPath, JSON.stringify(mockConfig), 'utf8');
+
+    try {
+      execSync('npx recoder-code run --prompt "Hello"', { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Invalid Open Router model');
+      }
+    }
+  });
+
+  it('should handle network errors gracefully', () => {
+    (axios.post as jest.Mock).mockRejectedValue(new Error('Network Error'));
+
+    try {
+      execSync('npx recoder-code run --prompt "Hello"', { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Error running prompt: Network Error');
+      }
+    }
+  });
+});

package/tests/cli-set-api-key.test.ts

@@ -0,0 +1,54 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+const configPath = path.join(__dirname, '..', '.recoderrc');
+
+beforeEach(() => {
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify({}), 'utf8');
+});
+
+afterEach(() => {
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+  }
+});
+
+describe('CLI Set API Key Command', () => {
+  it('should set the Open Router API key in .recoderrc', () => {
+    const mockApiKey = 'dummy-key';
+    execSync(`npx recoder-code set-api-key --key ${mockApiKey}`, { encoding: 'utf8' });
+
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    expect(config.openRouterApiKey).toBe(mockApiKey);
+  });
+
+  it('should create .recoderrc if it does not exist', () => {
+    const mockApiKey = 'dummy-key';
+    execSync(`npx recoder-code set-api-key --key ${mockApiKey}`, { encoding: 'utf8' });
+
+    expect(fs.existsSync(configPath)).toBe(true);
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    expect(config.openRouterApiKey).toBe(mockApiKey);
+  });
+
+  it('should handle missing key argument gracefully', () => {
+    const result = execSync('npx recoder-code set-api-key', { encoding: 'utf8' });
+    expect(result).toContain('Please provide an API key.');
+  });
+
+  it('should validate the API key format', () => {
+    const invalidApiKey = 'invalid-key';
+    try {
+      execSync(`npx recoder-code set-api-key --key ${invalidApiKey}`, { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Invalid Open Router API key format');
+      }
+    }
+  });
+});

package/tests/cli-validate-api-key.test.ts

@@ -0,0 +1,52 @@
+import fs from 'fs';
+import path from 'path';
+import { execSync } from 'child_process';
+
+const configPath = path.join(__dirname, '..', '.recoderrc');
+
+beforeEach(() => {
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+  }
+
+  fs.writeFileSync(configPath, JSON.stringify({}), 'utf8');
+});
+
+afterEach(() => {
+  if (fs.existsSync(configPath)) {
+    fs.unlinkSync(configPath);
+  }
+});
+
+describe('CLI Validate API Key Command', () => {
+  it('should validate a valid API key', () => {
+    const mockApiKey = 'valid-key';
+    fs.writeFileSync(configPath, JSON.stringify({ openRouterApiKey: mockApiKey }), 'utf8');
+
+    const result = execSync('npx recoder-code validate-api-key', { encoding: 'utf8' });
+    expect(result).toContain('API key is valid.');
+  });
+
+  it('should handle missing API key gracefully', () => {
+    try {
+      execSync('npx recoder-code validate-api-key', { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Open Router API key not found');
+      }
+    }
+  });
+
+  it('should handle invalid API keys gracefully', () => {
+    const mockApiKey = 'invalid-key';
+    fs.writeFileSync(configPath, JSON.stringify({ openRouterApiKey: mockApiKey }), 'utf8');
+
+    try {
+      execSync('npx recoder-code validate-api-key', { encoding: 'utf8' });
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Invalid Open Router API key');
+      }
+    }
+  });
+});

package/tsconfig.json

@@ -0,0 +1,18 @@
+{
+  "compilerOptions": {
+    "target": "ES6",
+    "module": "commonjs",
+    "strict": true,
+    "esModuleInterop": true,
+    "skipLibCheck": true,
+    "forceConsistentCasingInFileNames": true,
+    "outDir": "./dist",
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["*"]
+    },
+    "rootDir": "./src"
+  },
+  "include": ["src/**/*"],
+  "exclude": ["node_modules"]
+}