@qodo/sdk 0.6.0 → 0.7.0

package/.claude/skills/qodo-agent/assets/programmatic-agent.ts

@@ -23,8 +23,8 @@ import {
   zJsonAny,
   QodoSchemaError,
   QodoAuthError,
+  z
 } from '@qodo/sdk';
-import { z } from 'zod';
 
 // =============================================================================
 // STEP 1: Define Output Schemas
@@ -278,6 +278,7 @@ async function main() {
     if (refactorResult.success) {
       console.log('Refactor analysis complete!');
       console.log('Changes that would be made:');
+      // @ts-ignore
       refactorResult.structured_output?.changes_made?.forEach((change: any) => {
         console.log(`  - ${change.file}: ${change.description}`);
       });
@@ -293,7 +294,7 @@ async function main() {
     const promptResult = await sdk.prompt(
       'What are the most common patterns you see in this codebase?'
     );
-
+    // @ts-ignore
     console.log('Response:', promptResult.final_output);
   } catch (error) {
     // Handle specific error types

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qodo/sdk",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Qodo SDK for building AI-powered agents",
   "type": "module",
   "main": "./dist/index.js",
@@ -22,6 +22,8 @@
   },
   "files": [
     "dist",
+    "bin",
+    "scripts",
     ".claude/skills",
     "README.md",
     "LICENSE"
@@ -47,7 +49,8 @@
     "typecheck": "tsc --noEmit",
     "test": "vitest run",
     "test:watch": "vitest",
-    "prepublishOnly": "npm run build && npm run test"
+    "prepublishOnly": "npm run build && npm run test",
+    "postinstall": "node scripts/download-ripgrep.js"
   },
   "repository": {
     "type": "git",
@@ -74,7 +77,8 @@
     "uuid": "^11.1.0",
     "ws": "^8.18.3",
     "yaml": "^2.8.1",
-    "zod-to-json-schema": "^3.25.1"
+    "zod-to-json-schema": "^3.25.1",
+    "tar": "^7.4.3"
   },
   "peerDependencies": {
     "zod": "^3.25 || ^4.0",

package/scripts/download-ripgrep.js

@@ -0,0 +1,269 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { pipeline } from 'stream/promises';
+import { createWriteStream, createReadStream } from 'fs';
+import { promisify } from 'util';
+import { exec } from 'child_process';
+import https from 'https';
+import zlib from 'zlib';
+import * as tar from 'tar';
+
+const execAsync = promisify(exec);
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+
+// Constants
+const RIPGREP_VERSION = 'v13.0.0-13'; // Latest version from microsoft/ripgrep-prebuilt
+const RIPGREP_PRIMARY_BASE = 'https://rg.prod.qodo.ai'; // Primary CDN source
+const RIPGREP_FALLBACK_BASE = 'https://github.com/microsoft/ripgrep-prebuilt/releases/download'; // Fallback source
+const MAX_RETRIES = 3;
+const RETRY_DELAY = 1000; // 1 second
+
+// Platform mapping
+const PLATFORM_MAP = {
+  'darwin-arm64': 'aarch64-apple-darwin',
+  'darwin-x64': 'x86_64-apple-darwin',
+  'linux-x64': 'x86_64-unknown-linux-musl',
+  'linux-arm64': 'aarch64-unknown-linux-musl',
+  'win32-x64': 'x86_64-pc-windows-msvc',
+  'win32-arm64': 'aarch64-pc-windows-msvc'
+};
+
+// Get platform info
+function getPlatformInfo() {
+  const platform = process.platform;
+  const arch = process.arch === 'x64' ? 'x64' : process.arch;
+  const key = `${platform}-${arch}`;
+
+  const ripgrepPlatform = PLATFORM_MAP[key];
+  if (!ripgrepPlatform) {
+    throw new Error(`Unsupported platform: ${key}. Supported platforms: ${Object.keys(PLATFORM_MAP).join(', ')}`);
+  }
+
+  return {
+    platform,
+    arch,
+    ripgrepPlatform,
+    isWindows: platform === 'win32'
+  };
+}
+
+// Sleep utility for retry delays
+function sleep(ms) {
+  return new Promise(resolve => setTimeout(resolve, ms));
+}
+
+// Download file with progress and retry logic
+async function downloadFile(url, dest, retryCount = 0) {
+  return new Promise((resolve, reject) => {
+    const file = createWriteStream(dest);
+
+    https.get(url, (response) => {
+      if (response.statusCode === 302 || response.statusCode === 301) {
+        // Handle redirect
+        file.close();
+        if (fs.existsSync(dest)) fs.unlinkSync(dest);
+        downloadFile(response.headers.location, dest, retryCount).then(resolve).catch(reject);
+        return;
+      }
+
+      if (response.statusCode !== 200) {
+        file.close();
+        if (fs.existsSync(dest)) fs.unlinkSync(dest);
+        reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+        return;
+      }
+
+      const totalSize = parseInt(response.headers['content-length'], 10);
+      let downloadedSize = 0;
+
+      response.on('data', (chunk) => {
+        downloadedSize += chunk.length;
+        if (totalSize) {
+          const percent = ((downloadedSize / totalSize) * 100).toFixed(1);
+          process.stdout.write(`\rDownloading ripgrep: ${percent}%`);
+        }
+      });
+
+      response.pipe(file);
+
+      file.on('finish', () => {
+        file.close();
+        console.log('\nDownload complete');
+        resolve();
+      });
+
+      file.on('error', (err) => {
+        file.close();
+        if (fs.existsSync(dest)) fs.unlinkSync(dest);
+        reject(err);
+      });
+    }).on('error', (err) => {
+      file.close();
+      if (fs.existsSync(dest)) fs.unlinkSync(dest);
+      reject(err);
+    });
+  });
+}
+
+// Download with retry and fallback logic
+async function downloadWithRetry(urls, dest) {
+  for (let urlIndex = 0; urlIndex < urls.length; urlIndex++) {
+    const url = urls[urlIndex];
+    const isLastUrl = urlIndex === urls.length - 1;
+
+    for (let retry = 0; retry < MAX_RETRIES; retry++) {
+      const isLastRetry = retry === MAX_RETRIES - 1;
+
+      try {
+        console.log(`${retry > 0 ? 'Retrying' : 'Downloading'} from: ${url}${retry > 0 ? ` (attempt ${retry + 1}/${MAX_RETRIES})` : ''}`);
+        await downloadFile(url, dest);
+        return; // Success
+      } catch (error) {
+        console.log(`\nDownload failed: ${error.message}`);
+
+        if (isLastRetry && isLastUrl) {
+          // This was our last attempt with the last URL
+          throw error;
+        } else if (isLastRetry) {
+          // Last retry for this URL, try next URL
+          console.log(`Trying fallback source...`);
+          break;
+        } else {
+          // Not last retry, wait and try again with same URL
+          console.log(`Waiting ${RETRY_DELAY}ms before retry...`);
+          await sleep(RETRY_DELAY);
+        }
+      }
+    }
+  }
+}
+
+// Extract ripgrep binary from archive
+async function extractBinary(archivePath, platform, destDir) {
+  const binaryName = platform.isWindows ? 'rg.exe' : 'rg';
+  const destPath = path.join(destDir, binaryName);
+
+  if (platform.isWindows) {
+    // For Windows, it's a zip file
+    // We'll use the built-in tar command which supports zip on Windows 10+
+    try {
+      await execAsync(`tar -xf "${archivePath}" -C "${destDir}" "${binaryName}"`);
+    } catch (error) {
+      // Fallback: try PowerShell
+      console.log('Trying PowerShell extraction...');
+      await execAsync(`powershell -Command "Expand-Archive -Path '${archivePath}' -DestinationPath '${destDir}' -Force"`);
+      // Move the binary from the extracted folder
+      const extractedDir = fs.readdirSync(destDir).find(f => f.startsWith('ripgrep-'));
+      if (extractedDir) {
+        const sourcePath = path.join(destDir, extractedDir, binaryName);
+        await fs.promises.rename(sourcePath, destPath);
+        await fs.promises.rmdir(path.join(destDir, extractedDir), { recursive: true });
+      }
+    }
+  } else {
+    // For Unix systems, it's a tar.gz
+    await tar.x({
+      file: archivePath,
+      cwd: destDir,
+      filter: (path) => path.endsWith(binaryName)
+    });
+  }
+
+  // Make executable on Unix
+  if (!platform.isWindows) {
+    await fs.promises.chmod(destPath, 0o755);
+  }
+
+  return destPath;
+}
+
+// Main function
+async function main() {
+  console.log('Setting up ripgrep binary for @qodo/sdk...');
+
+  try {
+    // Get platform info
+    const platformInfo = getPlatformInfo();
+    console.log(`Platform detected: ${platformInfo.platform}-${platformInfo.arch}`);
+
+    // Setup paths
+    const binDir = path.join(__dirname, '..', 'bin');
+    const tempDir = path.join(__dirname, '..', '.tmp-ripgrep');
+
+    // Ensure directories exist
+    await fs.promises.mkdir(binDir, { recursive: true });
+    await fs.promises.mkdir(tempDir, { recursive: true });
+
+    // Check if ripgrep already exists
+    const binaryName = platformInfo.isWindows ? 'rg.exe' : 'rg';
+    const finalPath = path.join(binDir, binaryName);
+
+    if (fs.existsSync(finalPath)) {
+      console.log('Ripgrep binary already exists, verifying...');
+      try {
+        const { stdout } = await execAsync(`"${finalPath}" --version`);
+        console.log(`Existing ripgrep version: ${stdout.trim()}`);
+
+        // Clean up temp directory
+        await fs.promises.rm(tempDir, { recursive: true, force: true });
+        return;
+      } catch (error) {
+        console.log('Existing binary is invalid, re-downloading...');
+        await fs.promises.unlink(finalPath);
+      }
+    }
+
+    // Build download URLs (primary and fallback)
+    const archiveExt = platformInfo.isWindows ? '.zip' : '.tar.gz';
+    const fileName = `ripgrep-${RIPGREP_VERSION}-${platformInfo.ripgrepPlatform}${archiveExt}`;
+    const primaryUrl = `${RIPGREP_PRIMARY_BASE}/${fileName}`;
+    const fallbackUrl = `${RIPGREP_FALLBACK_BASE}/${RIPGREP_VERSION}/${fileName}`;
+    const archivePath = path.join(tempDir, fileName);
+
+    // Download the archive with retry and fallback
+    await downloadWithRetry([primaryUrl, fallbackUrl], archivePath);
+
+    // Extract the binary
+    console.log('Extracting ripgrep binary...');
+    const extractedPath = await extractBinary(archivePath, platformInfo, tempDir);
+
+    // Move to final location
+    await fs.promises.rename(extractedPath, finalPath);
+
+    // Verify installation
+    const { stdout } = await execAsync(`"${finalPath}" --version`);
+    console.log(`Successfully installed: ${stdout.trim()}`);
+
+    // Clean up
+    await fs.promises.rm(tempDir, { recursive: true, force: true });
+
+    console.log('Ripgrep setup complete!');
+  } catch (error) {
+    console.error('Error setting up ripgrep:', error.message);
+
+    // Clean up on error
+    const tempDir = path.join(__dirname, '..', '.tmp-ripgrep');
+    if (fs.existsSync(tempDir)) {
+      await fs.promises.rm(tempDir, { recursive: true, force: true });
+    }
+
+    // Check if running in CI or with --ignore-scripts
+    if (process.env.CI || process.env.npm_config_ignore_scripts) {
+      console.log('Running in CI or with --ignore-scripts, skipping ripgrep setup.');
+      process.exit(0);
+    }
+
+    console.log('\nNote: @qodo/sdk will fall back to system ripgrep if available.');
+    process.exit(0); // Exit gracefully to not break npm install
+  }
+}
+
+// Run if called directly
+if (process.argv[1] === fileURLToPath(import.meta.url)) {
+  main().catch(console.error);
+}
+
+export { main as downloadRipgrep };