recoder-code 1.0.113

package/config.json

@@ -0,0 +1,4 @@
+{
+  "openRouterApiKey": "",
+  "openRouterModel": "default-model"
+}

package/examples/gpt-3.5-turbo.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+
+const configPath = path.join(process.cwd(), '.recoderrc');
+
+try {
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+  if (!config.openRouterApiKey) {
+    console.error('Open Router API key not found. Please set it using: npx recoder-code set-api-key <your-open-router-api-key>');
+    process.exit(1);
+  }
+
+  const apiKey = config.openRouterApiKey;
+  const modelName = 'gpt-3.5-turbo';
+
+  // Example API request using the configured API key and model
+  const response = await axios.post(
+    `https://api.openrouter.com/v1/models/${modelName}/completions`,
+    {
+      prompt: "Hello, OpenRouter!",
+      max_tokens: 50
+    },
+    {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    }
+  );
+
+  console.log('Response from OpenRouter:', response.data.choices[0].text.trim());
+} catch (err) {
+  console.error('Error reading .recoderrc or making API request:', err.message);
+  process.exit(1);
+}

package/examples/gpt-4.js

@@ -0,0 +1,38 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const axios = require('axios');
+
+const configPath = path.join(process.cwd(), '.recoderrc');
+
+try {
+  const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+
+  if (!config.openRouterApiKey) {
+    console.error('Open Router API key not found. Please set it using: npx recoder-code set-api-key <your-open-router-api-key>');
+    process.exit(1);
+  }
+
+  const apiKey = config.openRouterApiKey;
+  const modelName = 'gpt-4';
+
+  // Example API request using the configured API key and model
+  const response = await axios.post(
+    `https://api.openrouter.com/v1/models/${modelName}/completions`,
+    {
+      prompt: "Hello, OpenRouter!",
+      max_tokens: 50
+    },
+    {
+      headers: {
+        'Authorization': `Bearer ${apiKey}`,
+        'Content-Type': 'application/json'
+      }
+    }
+  );
+
+  console.log('Response from OpenRouter:', response.data.choices[0].text.trim());
+} catch (err) {
+  console.error('Error reading .recoderrc or making API request:', err.message);
+  process.exit(1);
+}

package/examples/hooks/bash_command_validator_example.py

@@ -0,0 +1,83 @@
+#!/usr/bin/env python3
+"""
+Recoder Code Hook: Bash Command Validator
+=========================================
+This hook runs as a PreToolUse hook for the Bash tool.
+It validates bash commands against a set of rules before execution.
+In this case it changes grep calls to using rg.
+
+Read more about hooks here: https://docs.anthropic.com/en/docs/Recoder-code/hooks
+
+Make sure to change your path to your actual script.
+
+{
+  "hooks": {
+    "PreToolUse": [
+      {
+        "matcher": "Bash",
+        "hooks": [
+          {
+            "type": "command",
+            "command": "python3 /path/to/Recoder-code/examples/hooks/bash_command_validator_example.py"
+          }
+        ]
+      }
+    ]
+  }
+}
+
+"""
+
+import json
+import re
+import sys
+
+# Define validation rules as a list of (regex pattern, message) tuples
+_VALIDATION_RULES = [
+    (
+        r"^grep\b(?!.*\|)",
+        "Use 'rg' (ripgrep) instead of 'grep' for better performance and features",
+    ),
+    (
+        r"^find\s+\S+\s+-name\b",
+        "Use 'rg --files | rg pattern' or 'rg --files -g pattern' instead of 'find -name' for better performance",
+    ),
+]
+
+
+def _validate_command(command: str) -> list[str]:
+    issues = []
+    for pattern, message in _VALIDATION_RULES:
+        if re.search(pattern, command):
+            issues.append(message)
+    return issues
+
+
+def main():
+    try:
+        input_data = json.load(sys.stdin)
+    except json.JSONDecodeError as e:
+        print(f"Error: Invalid JSON input: {e}", file=sys.stderr)
+        # Exit code 1 shows stderr to the user but not to Recoder
+        sys.exit(1)
+
+    tool_name = input_data.get("tool_name", "")
+    if tool_name != "Bash":
+        sys.exit(0)
+
+    tool_input = input_data.get("tool_input", {})
+    command = tool_input.get("command", "")
+
+    if not command:
+        sys.exit(0)
+
+    issues = _validate_command(command)
+    if issues:
+        for message in issues:
+            print(f"• {message}", file=sys.stderr)
+        # Exit code 2 blocks tool call and shows stderr to Recoder
+        sys.exit(2)
+
+
+if __name__ == "__main__":
+    main()

package/index.d.ts

@@ -0,0 +1,3 @@
+declare module 'index.js' {
+  export const model: any;
+}

package/index.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+const fs = require('fs');
+const path = require('path');
+const readline = require('readline');
+
+const configPath = path.join(__dirname, 'config.json');
+
+// Check for API key in environment variable
+let apiKey = process.env.OPENROUTER_API_KEY;
+let model = process.env.OPENROUTER_MODEL || 'default-model';
+
+if (!apiKey) {
+  try {
+    // Read the config file if the environment variable is not set
+    const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+    apiKey = config.openRouterApiKey;
+    model = config.openRouterModel || 'default-model';
+  } catch (err) {
+    console.error('Error reading config.json:', err.message);
+  }
+}
+
+if (!apiKey || typeof apiKey !== 'string' || apiKey.trim().length === 0) {
+  // Prompt the user for the API key
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+
+  rl.question('Please enter your OpenRouter API key: ', (inputApiKey) => {
+    rl.close();
+    apiKey = inputApiKey.trim();
+
+    if (!apiKey || typeof apiKey !== 'string' || apiKey.length === 0) {
+      console.error('No valid Open Router API key provided. Exiting.');
+      process.exit(1);
+    }
+
+    // Save the API key to the config file
+    try {
+      const config = JSON.parse(fs.readFileSync(configPath, 'utf8'));
+      config.openRouterApiKey = apiKey;
+      config.openRouterModel = model;
+      fs.writeFileSync(configPath, JSON.stringify(config, null, 2));
+      console.log('Open Router API key saved to config.json.');
+    } catch (err) {
+      console.error('Error saving API key to config.json:', err.message);
+      process.exit(1);
+    }
+
+    console.log('recoder.xyz');
+    console.log('Open Router API key is set and valid.');
+  });
+} else {
+  console.log('recoder.xyz');
+  console.log('Open Router API key is set and valid.');
+}
+
+// Export the model for use in other modules
+module.exports = {
+  model: model
+};

package/jest.config.js

@@ -0,0 +1,6 @@
+module.exports = {
+  transform: {
+    '^.+\\.tsx?$': 'babel-jest',
+  },
+  transformIgnorePatterns: ['/node_modules/(?!(@babel|@octokit/core|@octokit/rest)/)'],
+};

package/openapi.yaml

@@ -0,0 +1,61 @@
+openapi: 3.0.0
+info:
+  title: Recoder API
+  description: API documentation for Recoder
+  version: 1.0.0
+servers:
+  - url: https://api.recoder.xyz
+    description: Production server
+  - url: https://engine.recoder.xyz
+    description: Engine server
+paths:
+  /chat/completions:
+    post:
+      summary: Create a chat completion
+      requestBody:
+        required: true
+        content:
+          application/json:
+            schema:
+              type: object
+              properties:
+                model:
+                  type: string
+                  description: The model to use for the completion.
+                messages:
+                  type: array
+                  items:
+                    type: object
+                    properties:
+                      role:
+                        type: string
+                        enum: [system, user, assistant]
+                      content:
+                        type: string
+                        description: The content of the message.
+      responses:
+        '200':
+          description: Successful response
+          content:
+            application/json:
+              schema:
+                type: object
+                properties:
+                  choices:
+                    type: array
+                    items:
+                      type: object
+                      properties:
+                        message:
+                          type: object
+                          properties:
+                            role:
+                              type: string
+                              enum: [system, user, assistant]
+                            content:
+                              type: string
+                              description: The content of the message.
+        '400':
+          description: Bad request
+        '500':
+          description: Internal server error

package/package.json

@@ -0,0 +1,47 @@
+{
+  "name": "recoder-code",
+  "version": "1.0.113",
+  "description": "An npm package that prints 'recoder.xyz' upon installation and allows users to utilize OpenRouter services with a valid API key.",
+  "main": "index.js",
+  "bin": {
+    "recoder-code": "cli/set-api-key.js",
+    "recoder-run": "cli/run.js",
+    "recoder-configure": "cli/configure.js",
+    "recoder-list-models": "cli/list-models.js"
+  },
+  "scripts": {
+    "set-api-key": "node cli/set-api-key.js",
+    "postinstall": "echo 'recoder.xyz'",
+    "test": "jest"
+  },
+  "config": {
+    "openRouterApiKey": ""
+  },
+  "dependencies": {
+    "@octokit/rest": "^22.0.0",
+    "axios": "^1.12.0",
+    "openai": "^5.20.1"
+  },
+  "devDependencies": {
+    "@babel/plugin-transform-modules-commonjs": "^7.27.1",
+    "@babel/preset-env": "^7.28.3",
+    "@babel/preset-typescript": "^7.27.1",
+    "@types/jest": "^30.0.0",
+    "babel-jest": "^30.1.2",
+    "jest": "^29.7.0",
+    "supertest": "^7.1.4",
+    "ts-jest": "^29.4.1",
+    "vitest": "^3.2.4"
+  },
+  "keywords": [
+    "recoder",
+    "openrouter",
+    "api"
+  ],
+  "author": "caelum0x",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/yourusername/recoder-package.git"
+  }
+}

package/scripts/backfill-duplicate-comments.ts

@@ -0,0 +1,213 @@
+#!/usr/bin/env bun
+
+declare global {
+  var process: {
+    env: Record<string, string | undefined>;
+  };
+}
+
+interface GitHubIssue {
+  number: number;
+  title: string;
+  state: string;
+  state_reason?: string;
+  user: { id: number };
+  created_at: string;
+  closed_at?: string;
+}
+
+interface GitHubComment {
+  id: number;
+  body: string;
+  created_at: string;
+  user: { type: string; id: number };
+}
+
+async function githubRequest<T>(endpoint: string, token: string, method: string = 'GET', body?: any): Promise<T> {
+  const response = await fetch(`https://api.github.com${endpoint}`, {
+    method,
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "backfill-duplicate-comments-script",
+      ...(body && { "Content-Type": "application/json" }),
+    },
+    ...(body && { body: JSON.stringify(body) }),
+  });
+
+  if (!response.ok) {
+    throw new Error(
+      `GitHub API request failed: ${response.status} ${response.statusText}`
+    );
+  }
+
+  return response.json();
+}
+
+async function triggerDedupeWorkflow(
+  owner: string,
+  repo: string,
+  issueNumber: number,
+  token: string,
+  dryRun: boolean = true
+): Promise<void> {
+  if (dryRun) {
+    console.log(`[DRY RUN] Would trigger dedupe workflow for issue #${issueNumber}`);
+    return;
+  }
+
+  await githubRequest(
+    `/repos/${owner}/${repo}/actions/workflows/claude-dedupe-issues.yml/dispatches`,
+    token,
+    'POST',
+    {
+      ref: 'main',
+      inputs: {
+        issue_number: issueNumber.toString()
+      }
+    }
+  );
+}
+
+async function backfillDuplicateComments(): Promise<void> {
+  console.log("[DEBUG] Starting backfill duplicate comments script");
+
+  const token = process.env.GITHUB_TOKEN;
+  if (!token) {
+    throw new Error(`GITHUB_TOKEN environment variable is required
+
+Usage:
+  GITHUB_TOKEN=your_token bun run scripts/backfill-duplicate-comments.ts
+
+Environment Variables:
+  GITHUB_TOKEN - GitHub personal access token with repo and actions permissions (required)
+  DRY_RUN - Set to "false" to actually trigger workflows (default: true for safety)
+  MAX_ISSUE_NUMBER - Only process issues with numbers less than this value (default: 4050)`);
+  }
+  console.log("[DEBUG] GitHub token found");
+
+  const owner = "anthropics";
+  const repo = "claude-code";
+  const dryRun = process.env.DRY_RUN !== "false";
+  const maxIssueNumber = parseInt(process.env.MAX_ISSUE_NUMBER || "4050", 10);
+  const minIssueNumber = parseInt(process.env.MIN_ISSUE_NUMBER || "1", 10);
+  
+  console.log(`[DEBUG] Repository: ${owner}/${repo}`);
+  console.log(`[DEBUG] Dry run mode: ${dryRun}`);
+  console.log(`[DEBUG] Looking at issues between #${minIssueNumber} and #${maxIssueNumber}`);
+
+  console.log(`[DEBUG] Fetching issues between #${minIssueNumber} and #${maxIssueNumber}...`);
+  const allIssues: GitHubIssue[] = [];
+  let page = 1;
+  const perPage = 100;
+  
+  while (true) {
+    const pageIssues: GitHubIssue[] = await githubRequest(
+      `/repos/${owner}/${repo}/issues?state=all&per_page=${perPage}&page=${page}&sort=created&direction=desc`,
+      token
+    );
+    
+    if (pageIssues.length === 0) break;
+    
+    // Filter to only include issues within the specified range
+    const filteredIssues = pageIssues.filter(issue => 
+      issue.number >= minIssueNumber && issue.number < maxIssueNumber
+    );
+    allIssues.push(...filteredIssues);
+    
+    // If the oldest issue in this page is still above our minimum, we need to continue
+    // but if the oldest issue is below our minimum, we can stop
+    const oldestIssueInPage = pageIssues[pageIssues.length - 1];
+    if (oldestIssueInPage && oldestIssueInPage.number >= maxIssueNumber) {
+      console.log(`[DEBUG] Oldest issue in page #${page} is #${oldestIssueInPage.number}, continuing...`);
+    } else if (oldestIssueInPage && oldestIssueInPage.number < minIssueNumber) {
+      console.log(`[DEBUG] Oldest issue in page #${page} is #${oldestIssueInPage.number}, below minimum, stopping`);
+      break;
+    } else if (filteredIssues.length === 0 && pageIssues.length > 0) {
+      console.log(`[DEBUG] No issues in page #${page} are in range #${minIssueNumber}-#${maxIssueNumber}, continuing...`);
+    }
+    
+    page++;
+    
+    // Safety limit to avoid infinite loops
+    if (page > 200) {
+      console.log("[DEBUG] Reached page limit, stopping pagination");
+      break;
+    }
+  }
+  
+  console.log(`[DEBUG] Found ${allIssues.length} issues between #${minIssueNumber} and #${maxIssueNumber}`);
+
+  let processedCount = 0;
+  let candidateCount = 0;
+  let triggeredCount = 0;
+
+  for (const issue of allIssues) {
+    processedCount++;
+    console.log(
+      `[DEBUG] Processing issue #${issue.number} (${processedCount}/${allIssues.length}): ${issue.title}`
+    );
+
+    console.log(`[DEBUG] Fetching comments for issue #${issue.number}...`);
+    const comments: GitHubComment[] = await githubRequest(
+      `/repos/${owner}/${repo}/issues/${issue.number}/comments`,
+      token
+    );
+    console.log(
+      `[DEBUG] Issue #${issue.number} has ${comments.length} comments`
+    );
+
+    // Look for existing duplicate detection comments (from the dedupe bot)
+    const dupeDetectionComments = comments.filter(
+      (comment) =>
+        comment.body.includes("Found") &&
+        comment.body.includes("possible duplicate") &&
+        comment.user.type === "Bot"
+    );
+
+    console.log(
+      `[DEBUG] Issue #${issue.number} has ${dupeDetectionComments.length} duplicate detection comments`
+    );
+
+    // Skip if there's already a duplicate detection comment
+    if (dupeDetectionComments.length > 0) {
+      console.log(
+        `[DEBUG] Issue #${issue.number} already has duplicate detection comment, skipping`
+      );
+      continue;
+    }
+
+    candidateCount++;
+    const issueUrl = `https://github.com/${owner}/${repo}/issues/${issue.number}`;
+    
+    try {
+      console.log(
+        `[INFO] ${dryRun ? '[DRY RUN] ' : ''}Triggering dedupe workflow for issue #${issue.number}: ${issueUrl}`
+      );
+      await triggerDedupeWorkflow(owner, repo, issue.number, token, dryRun);
+      
+      if (!dryRun) {
+        console.log(
+          `[SUCCESS] Successfully triggered dedupe workflow for issue #${issue.number}`
+        );
+      }
+      triggeredCount++;
+    } catch (error) {
+      console.error(
+        `[ERROR] Failed to trigger workflow for issue #${issue.number}: ${error}`
+      );
+    }
+
+    // Add a delay between workflow triggers to avoid overwhelming the system
+    await new Promise(resolve => setTimeout(resolve, 1000));
+  }
+
+  console.log(
+    `[DEBUG] Script completed. Processed ${processedCount} issues, found ${candidateCount} candidates without duplicate comments, ${dryRun ? 'would trigger' : 'triggered'} ${triggeredCount} workflows`
+  );
+}
+
+backfillDuplicateComments().catch(console.error);
+
+// Make it a module
+export {};

package/tests/api-githubApi.test.ts

@@ -0,0 +1,30 @@
+import { describe, it, expect } from '@jest/globals';
+import { getGitHubData } from '../api/githubApi';
+
+describe('GitHub API Functionality', () => {
+  it('should fetch data from GitHub API successfully', async () => {
+    const result = await getGitHubData('octocat', 'Hello-World');
+    expect(result).toHaveProperty('name', 'Hello-World');
+    expect(result).toHaveProperty('owner.login', 'octocat');
+  });
+
+  it('should handle invalid repository gracefully', async () => {
+    try {
+      await getGitHubData('octocat', 'nonexistent-repo');
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('Repository not found');
+      }
+    }
+  });
+
+  it('should handle invalid user gracefully', async () => {
+    try {
+      await getGitHubData('nonexistent-user', 'Hello-World');
+    } catch (error: unknown) {
+      if (error instanceof Error) {
+        expect(error.message).toContain('User not found');
+      }
+    }
+  });
+});