From 126e8c1135424ed5b03ab13830ece1c3bfc58c92 Mon Sep 17 00:00:00 2001 From: hannesrudolph Date: Wed, 2 Jul 2025 15:24:19 -0600 Subject: [PATCH] fix: address PR #5354 review feedback - Fixed duplicate 'codeIndex' sections in all 17 non-English locale files - Implemented memory management safeguards in WorkerPool: - Added queue size limits (default: 1000 tasks) - Added memory threshold monitoring (90% limit) - Added worker health checks with stale worker detection - Added status reporting method for monitoring - Made throttling interval configurable in CodeIndexStateManager - Added comprehensive worker message protocol documentation - Updated all WorkerPool instantiations to use new options-based constructor - Added tests for memory management features - Fixed unhandled promise rejection in health check test - Fixed ESLint warnings about Function type usage --- .../state-manager-throttling.spec.ts | 4 +- .../__tests__/worker-pool-memory.spec.ts | 181 +++++++++++++ .../code-index/__tests__/worker-pool.spec.ts | 22 +- src/services/code-index/manager.ts | 2 + src/services/code-index/processors/scanner.ts | 7 +- src/services/code-index/state-manager.ts | 8 +- .../code-index/workers/WORKER_PROTOCOL.md | 241 ++++++++++++++++++ .../code-index/workers/embedding.worker.ts | 18 +- .../code-index/workers/worker-pool.ts | 86 ++++++- webview-ui/src/i18n/locales/ca/settings.json | 34 --- webview-ui/src/i18n/locales/de/settings.json | 34 --- webview-ui/src/i18n/locales/es/settings.json | 34 --- webview-ui/src/i18n/locales/fr/settings.json | 34 --- webview-ui/src/i18n/locales/hi/settings.json | 34 --- webview-ui/src/i18n/locales/id/settings.json | 34 --- webview-ui/src/i18n/locales/it/settings.json | 34 --- webview-ui/src/i18n/locales/ja/settings.json | 34 --- webview-ui/src/i18n/locales/ko/settings.json | 34 --- webview-ui/src/i18n/locales/nl/settings.json | 34 --- webview-ui/src/i18n/locales/pl/settings.json | 34 --- .../src/i18n/locales/pt-BR/settings.json | 34 --- webview-ui/src/i18n/locales/ru/settings.json | 34 --- webview-ui/src/i18n/locales/tr/settings.json | 34 --- webview-ui/src/i18n/locales/vi/settings.json | 34 --- .../src/i18n/locales/zh-CN/settings.json | 34 --- .../src/i18n/locales/zh-TW/settings.json | 34 --- 26 files changed, 547 insertions(+), 600 deletions(-) create mode 100644 src/services/code-index/__tests__/worker-pool-memory.spec.ts create mode 100644 src/services/code-index/workers/WORKER_PROTOCOL.md diff --git a/src/services/code-index/__tests__/state-manager-throttling.spec.ts b/src/services/code-index/__tests__/state-manager-throttling.spec.ts index fb7e514fd3..3a0655d418 100644 --- a/src/services/code-index/__tests__/state-manager-throttling.spec.ts +++ b/src/services/code-index/__tests__/state-manager-throttling.spec.ts @@ -4,9 +4,9 @@ import { CodeIndexStateManager, IndexingState } from "../state-manager" // Mock vscode module vi.mock("vscode", () => ({ EventEmitter: class EventEmitter { - private listeners: Map = new Map() + private listeners: Map void>> = new Map() - event = (listener: Function) => { + event = (listener: (...args: any[]) => void) => { if (!this.listeners.has("event")) { this.listeners.set("event", []) } diff --git a/src/services/code-index/__tests__/worker-pool-memory.spec.ts b/src/services/code-index/__tests__/worker-pool-memory.spec.ts new file mode 100644 index 0000000000..c77c76f247 --- /dev/null +++ b/src/services/code-index/__tests__/worker-pool-memory.spec.ts @@ -0,0 +1,181 @@ +import { describe, it, expect, vi, beforeEach, afterEach } from "vitest" +import { WorkerPool } from "../workers/worker-pool" +import { EventEmitter } from "events" + +// Mock worker_threads module +vi.mock("worker_threads") + +// Mock os module +vi.mock("os", () => ({ + cpus: vi.fn(() => new Array(4)), +})) + +describe("WorkerPool - Memory Management", () => { + let pool: WorkerPool | null = null + let mockWorkers: any[] = [] + let Worker: any + + beforeEach(async () => { + vi.clearAllTimers() + vi.clearAllMocks() + mockWorkers = [] + pool = null + + // Get the mocked Worker class + const workerThreads = await import("worker_threads") + Worker = workerThreads.Worker + + // Reset and re-implement the Worker mock + vi.mocked(Worker).mockClear() + vi.mocked(Worker).mockImplementation((filename: string | URL) => { + const worker = new EventEmitter() + ;(worker as any).terminate = vi.fn().mockResolvedValue(undefined) + ;(worker as any).postMessage = vi.fn() + ;(worker as any).scriptPath = filename + mockWorkers.push(worker) + + // Simulate worker ready after a short delay + setTimeout(() => worker.emit("online"), 10) + + return worker as any + }) + }) + + afterEach(async () => { + if (pool) { + try { + await pool.shutdown() + } catch (e) { + // Ignore shutdown errors in tests + } + pool = null + } + + vi.clearAllMocks() + vi.clearAllTimers() + mockWorkers = [] + }) + + describe("queue size limits", () => { + it("should reject tasks when queue is full", async () => { + pool = new WorkerPool("/path/to/worker.js", { + maxWorkers: 1, + maxQueueSize: 2, + }) + + // Fill up the worker + const task1 = pool.execute({ type: "task1" }) + + // Fill up the queue + const task2 = pool.execute({ type: "task2" }) + const task3 = pool.execute({ type: "task3" }) + + // This should be rejected + await expect(pool.execute({ type: "task4" })).rejects.toThrow("Worker pool queue is full") + + // Complete tasks to avoid hanging + await new Promise((resolve) => setTimeout(resolve, 20)) + mockWorkers[0].emit("message", { success: true, data: "result1" }) + mockWorkers[0].emit("message", { success: true, data: "result2" }) + mockWorkers[0].emit("message", { success: true, data: "result3" }) + + await Promise.all([task1, task2, task3]) + }) + }) + + describe("memory threshold", () => { + it("should reject tasks when memory usage is too high", async () => { + // Mock process.memoryUsage to return high memory + const originalMemoryUsage = process.memoryUsage + process.memoryUsage = vi.fn().mockReturnValue({ + heapUsed: 600 * 1024 * 1024, // 600MB + heapTotal: 800 * 1024 * 1024, + external: 0, + arrayBuffers: 0, + rss: 900 * 1024 * 1024, + }) as any + + pool = new WorkerPool("/path/to/worker.js", { + maxWorkers: 2, + memoryThresholdMB: 500, // 500MB threshold + }) + + await expect(pool.execute({ type: "test" })).rejects.toThrow(/Memory usage too high/) + + // Restore original + process.memoryUsage = originalMemoryUsage + }) + }) + + describe("health checks", () => { + it("should perform periodic health checks", async () => { + vi.useFakeTimers() + const consoleDebugSpy = vi.spyOn(console, "debug").mockImplementation(() => {}) + + pool = new WorkerPool("/path/to/worker.js", { + maxWorkers: 2, + healthCheckIntervalMs: 1000, + }) + + // Advance time to trigger health check + vi.advanceTimersByTime(1000) + + // Health check should log status + expect(consoleDebugSpy).toHaveBeenCalledWith(expect.stringContaining("[WorkerPool] Status")) + + consoleDebugSpy.mockRestore() + vi.useRealTimers() + }) + + it("should replace stale workers", async () => { + vi.useFakeTimers() + const consoleWarnSpy = vi.spyOn(console, "warn").mockImplementation(() => {}) + + pool = new WorkerPool("/path/to/worker.js", { + maxWorkers: 1, + healthCheckIntervalMs: 1000, + }) + + // Start a task and handle the rejection + const taskPromise = pool.execute({ type: "test" }).catch((e: Error) => e) + + // Wait for task to be assigned + await vi.advanceTimersByTimeAsync(20) + + // Advance time past stale threshold (1 minute) + await vi.advanceTimersByTimeAsync(61000) + + // Task should be rejected due to timeout + const result = await taskPromise + expect(result).toBeInstanceOf(Error) + expect((result as Error).message).toBe("Worker task timed out") + + // Should log warning about stale worker + expect(consoleWarnSpy).toHaveBeenCalledWith(expect.stringContaining("Worker appears to be stale")) + + consoleWarnSpy.mockRestore() + vi.useRealTimers() + }) + }) + + describe("status reporting", () => { + it("should provide pool status", async () => { + pool = new WorkerPool("/path/to/worker.js", { + maxWorkers: 2, + maxQueueSize: 100, + memoryThresholdMB: 512, + }) + + const status = pool.getStatus() + + expect(status).toMatchObject({ + activeWorkers: 0, + availableWorkers: 2, + queueLength: 0, + maxQueueSize: 100, + memoryThresholdMB: 512, + }) + expect(status.memoryUsageMB).toBeGreaterThan(0) + }) + }) +}) diff --git a/src/services/code-index/__tests__/worker-pool.spec.ts b/src/services/code-index/__tests__/worker-pool.spec.ts index 4ed36de212..435a9015f4 100644 --- a/src/services/code-index/__tests__/worker-pool.spec.ts +++ b/src/services/code-index/__tests__/worker-pool.spec.ts @@ -60,7 +60,7 @@ describe("WorkerPool", () => { describe("initialization", () => { it("should create workers with specified concurrency", () => { - pool = new WorkerPool("/path/to/worker.js", 4) + pool = new WorkerPool("/path/to/worker.js", { maxWorkers: 4 }) expect(Worker).toHaveBeenCalledTimes(4) expect(Worker).toHaveBeenCalledWith("/path/to/worker.js") }) @@ -82,7 +82,7 @@ describe("WorkerPool", () => { describe("task execution", () => { beforeEach(() => { - pool = new WorkerPool("/path/to/worker.js", 2) + pool = new WorkerPool("/path/to/worker.js", { maxWorkers: 2 }) }) it("should execute tasks and return results", async () => { @@ -97,7 +97,7 @@ describe("WorkerPool", () => { // Simulate worker response const worker = mockWorkers[0] - const messageHandler = worker.listeners("message")[0] as Function + const messageHandler = worker.listeners("message")[0] as (...args: any[]) => void messageHandler(expectedResult) const result = await resultPromise @@ -142,7 +142,7 @@ describe("WorkerPool", () => { expect(mockWorkers[1].postMessage).toHaveBeenCalledTimes(1) // Complete first task - const messageHandler0 = mockWorkers[0].listeners("message")[0] as Function + const messageHandler0 = mockWorkers[0].listeners("message")[0] as (...args: any[]) => void messageHandler0({ success: true, data: "task1" }) // Wait for queue processing @@ -154,7 +154,7 @@ describe("WorkerPool", () => { // Complete remaining tasks messageHandler0({ success: true, data: "task3" }) - const messageHandler1 = mockWorkers[1].listeners("message")[0] as Function + const messageHandler1 = mockWorkers[1].listeners("message")[0] as (...args: any[]) => void messageHandler1({ success: true, data: "task2" }) const results = await Promise.all(promises) @@ -206,7 +206,7 @@ describe("WorkerPool", () => { describe("shutdown", () => { beforeEach(() => { - pool = new WorkerPool("/path/to/worker.js", 2) + pool = new WorkerPool("/path/to/worker.js", { maxWorkers: 2 }) }) it("should terminate all workers", async () => { @@ -218,7 +218,7 @@ describe("WorkerPool", () => { it("should reject pending tasks on shutdown", async () => { // Create a new pool with limited workers - const testPool = new WorkerPool("/path/to/worker.js", 1) + const testPool = new WorkerPool("/path/to/worker.js", { maxWorkers: 1 }) // Wait for workers to be ready await new Promise((resolve) => setTimeout(resolve, 20)) @@ -272,7 +272,7 @@ describe("WorkerPool", () => { describe("error handling", () => { beforeEach(() => { - pool = new WorkerPool("/path/to/worker.js", 1) + pool = new WorkerPool("/path/to/worker.js", { maxWorkers: 1 }) }) it("should handle worker initialization errors", async () => { @@ -316,7 +316,7 @@ describe("WorkerPool", () => { describe("performance", () => { it("should process tasks concurrently", async () => { - pool = new WorkerPool("/path/to/worker.js", 3) + pool = new WorkerPool("/path/to/worker.js", { maxWorkers: 3 }) const tasks = Array(6) .fill(null) @@ -331,7 +331,7 @@ describe("WorkerPool", () => { // Complete first batch of tasks for (let i = 0; i < 3; i++) { const worker = mockWorkers[i] - const handler = worker.listeners("message")[0] as Function + const handler = worker.listeners("message")[0] as (...args: any[]) => void handler({ success: true, data: `result${i}` }) } @@ -341,7 +341,7 @@ describe("WorkerPool", () => { // Complete second batch for (let i = 0; i < 3; i++) { const worker = mockWorkers[i] - const handler = worker.listeners("message")[0] as Function + const handler = worker.listeners("message")[0] as (...args: any[]) => void handler({ success: true, data: `result${i + 3}` }) } diff --git a/src/services/code-index/manager.ts b/src/services/code-index/manager.ts index 5d413cffe7..9499fc0545 100644 --- a/src/services/code-index/manager.ts +++ b/src/services/code-index/manager.ts @@ -52,6 +52,8 @@ export class CodeIndexManager { private constructor(workspacePath: string, context: vscode.ExtensionContext) { this.workspacePath = workspacePath this.context = context + // Create state manager with default throttle interval (500ms) + // Can be customized by passing a different value to the constructor this._stateManager = new CodeIndexStateManager() } diff --git a/src/services/code-index/processors/scanner.ts b/src/services/code-index/processors/scanner.ts index fa5a358702..dc078108dc 100644 --- a/src/services/code-index/processors/scanner.ts +++ b/src/services/code-index/processors/scanner.ts @@ -42,10 +42,9 @@ export class DirectoryScanner implements IDirectoryScanner { ) { // Initialize worker pool for file processing try { - this.workerPool = new WorkerPool( - path.join(__dirname, "../workers/file-processor.worker.js"), - PARSING_CONCURRENCY, - ) + this.workerPool = new WorkerPool(path.join(__dirname, "../workers/file-processor.worker.js"), { + maxWorkers: PARSING_CONCURRENCY, + }) } catch (error) { console.warn( "[DirectoryScanner] Failed to initialize worker pool, falling back to main thread processing:", diff --git a/src/services/code-index/state-manager.ts b/src/services/code-index/state-manager.ts index 8c274d15c7..0f934fb9c6 100644 --- a/src/services/code-index/state-manager.ts +++ b/src/services/code-index/state-manager.ts @@ -13,7 +13,11 @@ export class CodeIndexStateManager { // Throttling properties private _throttleTimer?: NodeJS.Timeout private _pendingUpdate?: ReturnType - private readonly THROTTLE_INTERVAL_MS = 500 + private readonly throttleIntervalMs: number + + constructor(throttleIntervalMs: number = 500) { + this.throttleIntervalMs = throttleIntervalMs + } // --- Public API --- @@ -128,7 +132,7 @@ export class CodeIndexStateManager { this._pendingUpdate = undefined } this._throttleTimer = undefined - }, this.THROTTLE_INTERVAL_MS) + }, this.throttleIntervalMs) } public dispose(): void { diff --git a/src/services/code-index/workers/WORKER_PROTOCOL.md b/src/services/code-index/workers/WORKER_PROTOCOL.md new file mode 100644 index 0000000000..59d43afb9a --- /dev/null +++ b/src/services/code-index/workers/WORKER_PROTOCOL.md @@ -0,0 +1,241 @@ +# Worker Message Protocol Documentation + +This document describes the message protocol used for communication between the main thread and worker threads in the code indexing system. + +## Overview + +The worker pool system uses a request-response pattern where: + +- The main thread sends tasks to workers via `postMessage` +- Workers process tasks and respond with results or errors +- Each message includes a unique ID for correlation + +## Message Format + +### Request Message (Main → Worker) + +```typescript +interface WorkerRequest { + id: string // Unique identifier for request/response correlation + type: string // Task type identifier + data?: any // Task-specific payload +} +``` + +### Response Message (Worker → Main) + +```typescript +interface WorkerResponse { + id: string // Matches the request ID + error?: string // Error message if task failed + result?: any // Task result if successful +} +``` + +## Worker Types and Their Protocols + +### 1. File Processor Worker (`file-processor.worker.ts`) + +**Purpose**: Processes source code files to extract semantic blocks for indexing. + +**Request Types**: + +#### `process-file` + +Processes a single file to extract code blocks. + +```typescript +// Request +{ + id: "unique-id", + type: "process-file", + data: { + filePath: string; // Absolute path to file + content: string; // File content + language: string; // Programming language + maxBlockSize?: number; // Optional: max chars per block (default: 1000) + } +} + +// Response +{ + id: "unique-id", + result: { + blocks: Array<{ + content: string; // Block content + startLine: number; // Starting line number + endLine: number; // Ending line number + metadata?: { // Optional metadata + type?: string; // Block type (function, class, etc.) + name?: string; // Block name if applicable + } + }> + } +} +``` + +### 2. Embedding Worker (`embedding.worker.ts`) + +**Purpose**: Placeholder for future AI embedding generation. + +**Status**: Currently a placeholder that echoes back input. Will be implemented when AI embedding service is integrated. + +**Request Types**: + +#### `generate-embedding` (Placeholder) + +```typescript +// Request +{ + id: "unique-id", + type: "generate-embedding", + data: { + text: string; // Text to generate embedding for + } +} + +// Response (Placeholder) +{ + id: "unique-id", + result: { + embedding: string; // Currently just echoes input + } +} +``` + +## Worker Pool Management + +The `WorkerPool` class manages worker lifecycle and task distribution: + +### Task Execution Flow + +1. **Task Submission**: Main thread calls `pool.execute(task)` +2. **Worker Selection**: Pool selects an available worker or queues the task +3. **Task Dispatch**: Task is sent to worker via `postMessage` +4. **Response Handling**: Worker response is correlated by ID and promise is resolved/rejected +5. **Worker Release**: Worker is marked as available for next task + +### Memory Management + +The worker pool implements several memory safeguards: + +- **Queue Size Limits**: Maximum number of pending tasks (default: 1000) +- **Memory Monitoring**: Checks available memory before accepting tasks +- **Health Checks**: Periodic checks to detect and replace stale workers +- **Graceful Degradation**: Rejects new tasks when memory is low + +### Error Handling + +Workers should handle errors gracefully: + +```typescript +// In worker +parentPort.on("message", async (message) => { + const { id, type, data } = message + + try { + const result = await processTask(type, data) + parentPort.postMessage({ id, result }) + } catch (error) { + parentPort.postMessage({ + id, + error: error.message || "Unknown error", + }) + } +}) +``` + +## Best Practices + +1. **Always Include ID**: Every request must have a unique ID for correlation +2. **Error Messages**: Provide descriptive error messages for debugging +3. **Timeout Handling**: Workers should not block indefinitely +4. **Memory Efficiency**: Process data in chunks when possible +5. **Type Safety**: Use TypeScript interfaces for message types + +## Adding New Worker Types + +To add a new worker type: + +1. Create a new worker file (e.g., `my-task.worker.ts`) +2. Implement the message handler following the protocol +3. Define request/response interfaces +4. Update this documentation with the new protocol +5. Add tests for the new worker type + +Example template: + +```typescript +import { parentPort } from "worker_threads" + +if (!parentPort) throw new Error("This file must be run as a worker") + +parentPort.on("message", async (message) => { + const { id, type, data } = message + + try { + let result + + switch (type) { + case "my-task": + result = await performMyTask(data) + break + default: + throw new Error(`Unknown task type: ${type}`) + } + + parentPort.postMessage({ id, result }) + } catch (error) { + parentPort.postMessage({ + id, + error: error instanceof Error ? error.message : "Unknown error", + }) + } +}) + +async function performMyTask(data: any) { + // Implementation here + return { + /* result */ + } +} +``` + +## Testing Workers + +Workers can be tested in isolation: + +```typescript +describe("MyWorker", () => { + let pool: WorkerPool + + beforeEach(() => { + pool = new WorkerPool("/path/to/worker.js", { maxWorkers: 1 }) + }) + + afterEach(() => { + pool.terminate() + }) + + it("should process task", async () => { + const result = await pool.execute({ + type: "my-task", + data: { + /* test data */ + }, + }) + + expect(result).toEqual({ + /* expected result */ + }) + }) +}) +``` + +## Future Enhancements + +1. **Streaming Responses**: Support for streaming large results +2. **Progress Reporting**: Allow workers to report progress on long tasks +3. **Priority Queuing**: Support for high-priority tasks +4. **Worker Pooling by Type**: Separate pools for different worker types +5. **Metrics Collection**: Performance and usage metrics diff --git a/src/services/code-index/workers/embedding.worker.ts b/src/services/code-index/workers/embedding.worker.ts index cc129da7d7..4a8dc85ec4 100644 --- a/src/services/code-index/workers/embedding.worker.ts +++ b/src/services/code-index/workers/embedding.worker.ts @@ -1,3 +1,17 @@ +/** + * Embedding Worker - Placeholder Implementation + * + * This worker is designed to handle embedding generation in a separate thread + * to prevent blocking the main thread during intensive computation. + * + * Current status: This is a placeholder implementation that returns dummy embeddings. + * Future implementation will integrate with actual embedding providers (OpenAI, Ollama, etc.) + * to generate real embeddings for code chunks. + * + * The worker pool architecture allows for parallel processing of embedding requests, + * improving performance for large codebases. + */ + import { parentPort } from "worker_threads" import { WorkerTask, WorkerResult } from "./worker-pool" @@ -11,8 +25,8 @@ interface EmbeddingResult { embeddings: number[][] } -// Note: In a real implementation, this would use the actual embedder -// For now, we'll create a placeholder that demonstrates the structure +// TODO: Replace with actual embedder implementation +// This placeholder demonstrates the expected structure and interface async function generateEmbeddings(task: EmbeddingTask): Promise { try { // In production, this would: diff --git a/src/services/code-index/workers/worker-pool.ts b/src/services/code-index/workers/worker-pool.ts index 4ff35b55f4..4e3add562b 100644 --- a/src/services/code-index/workers/worker-pool.ts +++ b/src/services/code-index/workers/worker-pool.ts @@ -18,20 +18,41 @@ interface QueueItem { reject: (reason: any) => void } +export interface WorkerPoolOptions { + maxWorkers?: number + maxQueueSize?: number + memoryThresholdMB?: number + healthCheckIntervalMs?: number +} + export class WorkerPool { private workers: Worker[] = [] private availableWorkers: Worker[] = [] private queue: QueueItem[] = [] private activeWorkers = new Map>() private isShuttingDown = false + private maxQueueSize: number + private memoryThresholdMB: number + private healthCheckInterval?: NodeJS.Timeout + private workerLastActivity = new Map() constructor( private workerScript: string, - private maxWorkers = Math.max(1, cpus().length - 1), + options: WorkerPoolOptions = {}, ) { + this.maxWorkers = options.maxWorkers ?? Math.max(1, cpus().length - 1) + this.maxQueueSize = options.maxQueueSize ?? 1000 + this.memoryThresholdMB = options.memoryThresholdMB ?? 512 + this.initializeWorkers() + + if (options.healthCheckIntervalMs) { + this.startHealthChecks(options.healthCheckIntervalMs) + } } + private maxWorkers: number + private initializeWorkers(): void { for (let i = 0; i < this.maxWorkers; i++) { const worker = new Worker(this.workerScript) @@ -119,6 +140,19 @@ export class WorkerPool { throw new Error("Worker pool is shutting down") } + // Check queue size limit + if (this.queue.length >= this.maxQueueSize) { + throw new Error(`Worker pool queue is full (max: ${this.maxQueueSize})`) + } + + // Check memory usage + const memoryUsageMB = process.memoryUsage().heapUsed / 1024 / 1024 + if (memoryUsageMB > this.memoryThresholdMB) { + throw new Error( + `Memory usage too high: ${memoryUsageMB.toFixed(2)}MB (threshold: ${this.memoryThresholdMB}MB)`, + ) + } + return new Promise((resolve, reject) => { this.queue.push({ task, resolve, reject }) this.processQueue() @@ -131,13 +165,62 @@ export class WorkerPool { const worker = this.availableWorkers.shift()! this.activeWorkers.set(worker, queueItem) + this.workerLastActivity.set(worker, Date.now()) worker.postMessage(queueItem.task) } } + private startHealthChecks(intervalMs: number): void { + this.healthCheckInterval = setInterval(() => { + this.performHealthCheck() + }, intervalMs) + } + + private performHealthCheck(): void { + const now = Date.now() + const staleThreshold = 60000 // 1 minute + + for (const [worker, lastActivity] of this.workerLastActivity) { + if (this.activeWorkers.has(worker) && now - lastActivity > staleThreshold) { + console.warn(`[WorkerPool] Worker appears to be stale, replacing...`) + + // Reject the stale task + const queueItem = this.activeWorkers.get(worker) + if (queueItem) { + queueItem.reject(new Error("Worker task timed out")) + this.activeWorkers.delete(worker) + } + + // Replace the stale worker + this.replaceWorker(worker) + } + } + + // Log pool status + console.debug( + `[WorkerPool] Status - Active: ${this.activeWorkers.size}, Available: ${this.availableWorkers.length}, Queue: ${this.queue.length}`, + ) + } + + getStatus() { + return { + activeWorkers: this.activeWorkers.size, + availableWorkers: this.availableWorkers.length, + queueLength: this.queue.length, + maxQueueSize: this.maxQueueSize, + memoryUsageMB: process.memoryUsage().heapUsed / 1024 / 1024, + memoryThresholdMB: this.memoryThresholdMB, + } + } + async shutdown(): Promise { this.isShuttingDown = true + // Stop health checks + if (this.healthCheckInterval) { + clearInterval(this.healthCheckInterval) + } + // Clear the queue for (const queueItem of this.queue) { queueItem.reject(new Error("Worker pool is shutting down")) @@ -167,5 +250,6 @@ export class WorkerPool { this.workers = [] this.availableWorkers = [] this.activeWorkers.clear() + this.workerLastActivity.clear() } } diff --git a/webview-ui/src/i18n/locales/ca/settings.json b/webview-ui/src/i18n/locales/ca/settings.json index 9c9ab5e4ef..3797725a82 100644 --- a/webview-ui/src/i18n/locales/ca/settings.json +++ b/webview-ui/src/i18n/locales/ca/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Configura les indicacions de suport utilitzades per a accions ràpides com millorar indicacions, explicar codi i solucionar problemes. Aquestes indicacions ajuden Roo a proporcionar millor assistència per a tasques comunes de desenvolupament." }, - "codeIndex": { - "title": "Indexació de codi", - "enableLabel": "Habilitar indexació de codi", - "enableDescription": "<0>Indexació de codi és una característica experimental que crea un índex de cerca semàntica del vostre projecte utilitzant embeddings d'IA. Això permet a Roo Code entendre millor i navegar per grans bases de codi trobant codi rellevant basat en significat en lloc de només paraules clau.", - "providerLabel": "Proveïdor d'embeddings", - "selectProviderPlaceholder": "Seleccionar proveïdor", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "Compatible amb OpenAI", - "openaiCompatibleBaseUrlLabel": "URL base:", - "openaiCompatibleApiKeyLabel": "Clau API:", - "openaiCompatibleModelDimensionLabel": "Dimensió d'Embedding:", - "openaiCompatibleModelDimensionPlaceholder": "p. ex., 1536", - "openaiCompatibleModelDimensionDescription": "La dimensió d'embedding (mida de sortida) per al teu model. Consulta la documentació del teu proveïdor per a aquest valor. Valors comuns: 384, 768, 1536, 3072.", - "openaiKeyLabel": "Clau OpenAI:", - "modelLabel": "Model", - "selectModelPlaceholder": "Seleccionar model", - "ollamaUrlLabel": "URL d'Ollama:", - "qdrantUrlLabel": "URL de Qdrant", - "qdrantKeyLabel": "Clau de Qdrant:", - "advancedConfigLabel": "Configuració avançada", - "searchMinScoreLabel": "Llindar de puntuació de cerca", - "searchMinScoreDescription": "Puntuació mínima de similitud (0.0-1.0) requerida per als resultats de la cerca. Valors més baixos retornen més resultats però poden ser menys rellevants. Valors més alts retornen menys resultats però més rellevants.", - "searchMinScoreResetTooltip": "Restablir al valor per defecte (0.4)", - "startIndexingButton": "Iniciar indexació", - "clearIndexDataButton": "Esborrar dades d'índex", - "unsavedSettingsMessage": "Si us plau, deseu la configuració abans d'iniciar el procés d'indexació.", - "clearDataDialog": { - "title": "Esteu segur?", - "description": "Aquesta acció no es pot desfer. Eliminarà permanentment les dades d'índex de la vostra base de codi.", - "cancelButton": "Cancel·lar", - "confirmButton": "Esborrar dades" - } - }, "codeIndex": { "title": "Indexació de la base de codi", "enableLabel": "Activa la indexació de la base de codi", diff --git a/webview-ui/src/i18n/locales/de/settings.json b/webview-ui/src/i18n/locales/de/settings.json index 7d61aa80f9..ebeb407f9e 100644 --- a/webview-ui/src/i18n/locales/de/settings.json +++ b/webview-ui/src/i18n/locales/de/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Konfiguriere Support-Prompts, die für schnelle Aktionen wie das Verbessern von Prompts, das Erklären von Code und das Beheben von Problemen verwendet werden. Diese Prompts helfen Roo dabei, bessere Unterstützung für häufige Entwicklungsaufgaben zu bieten." }, - "codeIndex": { - "title": "Codebase-Indexierung", - "enableLabel": "Codebase-Indexierung aktivieren", - "enableDescription": "<0>Codebase-Indexierung ist eine experimentelle Funktion, die einen semantischen Suchindex deines Projekts mit KI-Embeddings erstellt. Dies ermöglicht es Roo Code, große Codebasen besser zu verstehen und zu navigieren, indem relevanter Code basierend auf Bedeutung statt nur Schlüsselwörtern gefunden wird.", - "providerLabel": "Embeddings-Anbieter", - "selectProviderPlaceholder": "Anbieter auswählen", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI-kompatibel", - "openaiCompatibleBaseUrlLabel": "Basis-URL:", - "openaiCompatibleApiKeyLabel": "API-Schlüssel:", - "openaiCompatibleModelDimensionLabel": "Embedding-Dimension:", - "openaiCompatibleModelDimensionPlaceholder": "z.B. 1536", - "openaiCompatibleModelDimensionDescription": "Die Embedding-Dimension (Ausgabegröße) für Ihr Modell. Überprüfen Sie die Dokumentation Ihres Anbieters für diesen Wert. Übliche Werte: 384, 768, 1536, 3072.", - "openaiKeyLabel": "OpenAI-Schlüssel:", - "modelLabel": "Modell", - "selectModelPlaceholder": "Modell auswählen", - "ollamaUrlLabel": "Ollama-URL:", - "qdrantUrlLabel": "Qdrant-URL", - "qdrantKeyLabel": "Qdrant-Schlüssel:", - "advancedConfigLabel": "Erweiterte Konfiguration", - "searchMinScoreLabel": "Suchergebnis-Schwellenwert", - "searchMinScoreDescription": "Mindestähnlichkeitswert (0.0-1.0), der für Suchergebnisse erforderlich ist. Niedrigere Werte liefern mehr Ergebnisse, die jedoch möglicherweise weniger relevant sind. Höhere Werte liefern weniger, aber relevantere Ergebnisse.", - "searchMinScoreResetTooltip": "Auf Standardwert zurücksetzen (0.4)", - "startIndexingButton": "Indexierung starten", - "clearIndexDataButton": "Indexdaten löschen", - "unsavedSettingsMessage": "Bitte speichere deine Einstellungen, bevor du den Indexierungsprozess startest.", - "clearDataDialog": { - "title": "Sind Sie sicher?", - "description": "Diese Aktion kann nicht rückgängig gemacht werden. Dies wird Ihre Codebase-Indexdaten dauerhaft löschen.", - "cancelButton": "Abbrechen", - "confirmButton": "Daten löschen" - } - }, "codeIndex": { "title": "Codebasis-Indizierung", "enableLabel": "Codebasis-Indizierung aktivieren", diff --git a/webview-ui/src/i18n/locales/es/settings.json b/webview-ui/src/i18n/locales/es/settings.json index 4b023cb847..2d7ff45fe5 100644 --- a/webview-ui/src/i18n/locales/es/settings.json +++ b/webview-ui/src/i18n/locales/es/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Configura indicaciones de soporte que se utilizan para acciones rápidas como mejorar indicaciones, explicar código y solucionar problemas. Estas indicaciones ayudan a Roo a brindar mejor asistencia para tareas comunes de desarrollo." }, - "codeIndex": { - "title": "Indexación de código", - "enableLabel": "Habilitar indexación de código", - "enableDescription": "<0>La indexación de código es una función experimental que crea un índice de búsqueda semántica de tu proyecto usando embeddings de IA. Esto permite a Roo Code entender mejor y navegar grandes bases de código encontrando código relevante basado en significado en lugar de solo palabras clave.", - "providerLabel": "Proveedor de embeddings", - "selectProviderPlaceholder": "Seleccionar proveedor", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "Compatible con OpenAI", - "openaiCompatibleBaseUrlLabel": "URL base:", - "openaiCompatibleApiKeyLabel": "Clave API:", - "openaiCompatibleModelDimensionLabel": "Dimensión de Embedding:", - "openaiCompatibleModelDimensionPlaceholder": "ej., 1536", - "openaiCompatibleModelDimensionDescription": "La dimensión de embedding (tamaño de salida) para tu modelo. Consulta la documentación de tu proveedor para este valor. Valores comunes: 384, 768, 1536, 3072.", - "openaiKeyLabel": "Clave de OpenAI:", - "modelLabel": "Modelo", - "selectModelPlaceholder": "Seleccionar modelo", - "ollamaUrlLabel": "URL de Ollama:", - "qdrantUrlLabel": "URL de Qdrant", - "qdrantKeyLabel": "Clave de Qdrant:", - "advancedConfigLabel": "Configuración avanzada", - "searchMinScoreLabel": "Umbral de puntuación de búsqueda", - "searchMinScoreDescription": "Puntuación mínima de similitud (0.0-1.0) requerida para los resultados de búsqueda. Valores más bajos devuelven más resultados pero pueden ser menos relevantes. Valores más altos devuelven menos resultados pero más relevantes.", - "searchMinScoreResetTooltip": "Restablecer al valor predeterminado (0.4)", - "startIndexingButton": "Iniciar indexación", - "clearIndexDataButton": "Borrar datos de índice", - "unsavedSettingsMessage": "Por favor guarda tus ajustes antes de iniciar el proceso de indexación.", - "clearDataDialog": { - "title": "¿Estás seguro?", - "description": "Esta acción no se puede deshacer. Esto eliminará permanentemente los datos de índice de tu base de código.", - "cancelButton": "Cancelar", - "confirmButton": "Borrar datos" - } - }, "codeIndex": { "title": "Indexación de la base de código", "enableLabel": "Habilitar la indexación de la base de código", diff --git a/webview-ui/src/i18n/locales/fr/settings.json b/webview-ui/src/i18n/locales/fr/settings.json index 261e7c7e02..d6d56e8baf 100644 --- a/webview-ui/src/i18n/locales/fr/settings.json +++ b/webview-ui/src/i18n/locales/fr/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Configurez les invites de support utilisées pour les actions rapides comme l'amélioration des invites, l'explication du code et la résolution des problèmes. Ces invites aident Roo à fournir une meilleure assistance pour les tâches de développement courantes." }, - "codeIndex": { - "title": "Indexation de la base de code", - "enableLabel": "Activer l'indexation de la base de code", - "enableDescription": "<0>L'indexation de la base de code est une fonctionnalité expérimentale qui crée un index de recherche sémantique de votre projet en utilisant des embeddings IA. Cela permet à Roo Code de mieux comprendre et naviguer dans de grandes bases de code en trouvant du code pertinent basé sur le sens plutôt que seulement sur des mots-clés.", - "providerLabel": "Fournisseur d'embeddings", - "selectProviderPlaceholder": "Sélectionner un fournisseur", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "Compatible OpenAI", - "openaiCompatibleBaseUrlLabel": "URL de base :", - "openaiCompatibleApiKeyLabel": "Clé API :", - "openaiCompatibleModelDimensionLabel": "Dimension d'Embedding :", - "openaiCompatibleModelDimensionPlaceholder": "ex., 1536", - "openaiCompatibleModelDimensionDescription": "La dimension d'embedding (taille de sortie) pour votre modèle. Consultez la documentation de votre fournisseur pour cette valeur. Valeurs courantes : 384, 768, 1536, 3072.", - "openaiKeyLabel": "Clé OpenAI :", - "modelLabel": "Modèle", - "selectModelPlaceholder": "Sélectionner un modèle", - "ollamaUrlLabel": "URL Ollama :", - "qdrantUrlLabel": "URL Qdrant", - "qdrantKeyLabel": "Clé Qdrant :", - "advancedConfigLabel": "Configuration avancée", - "searchMinScoreLabel": "Seuil de score de recherche", - "searchMinScoreDescription": "Score de similarité minimum (0.0-1.0) requis pour les résultats de recherche. Des valeurs plus faibles renvoient plus de résultats mais peuvent être moins pertinents. Des valeurs plus élevées renvoient moins de résultats mais plus pertinents.", - "searchMinScoreResetTooltip": "Réinitialiser à la valeur par défaut (0.4)", - "startIndexingButton": "Démarrer l'indexation", - "clearIndexDataButton": "Effacer les données d'index", - "unsavedSettingsMessage": "Merci d'enregistrer tes paramètres avant de démarrer le processus d'indexation.", - "clearDataDialog": { - "title": "Êtes-vous sûr ?", - "description": "Cette action ne peut pas être annulée. Cela supprimera définitivement les données d'index de votre base de code.", - "cancelButton": "Annuler", - "confirmButton": "Effacer les données" - } - }, "codeIndex": { "title": "Indexation de la base de code", "enableLabel": "Activer l'indexation de la base de code", diff --git a/webview-ui/src/i18n/locales/hi/settings.json b/webview-ui/src/i18n/locales/hi/settings.json index e2221c017a..71aa9922dc 100644 --- a/webview-ui/src/i18n/locales/hi/settings.json +++ b/webview-ui/src/i18n/locales/hi/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "प्रॉम्प्ट्स को बेहतर बनाना, कोड की व्याख्या करना और समस्याओं को ठीक करना जैसी त्वरित कार्रवाइयों के लिए उपयोग किए जाने वाले सहायक प्रॉम्प्ट्स को कॉन्फ़िगर करें। ये प्रॉम्प्ट्स Roo को सामान्य विकास कार्यों के लिए बेहतर सहायता प्रदान करने में मदद करते हैं।" }, - "codeIndex": { - "title": "कोडबेस इंडेक्सिंग", - "enableLabel": "कोडबेस इंडेक्सिंग सक्षम करें", - "enableDescription": "<0>कोडबेस इंडेक्सिंग एक प्रयोगात्मक सुविधा है जो AI एम्बेडिंग का उपयोग करके आपके प्रोजेक्ट का सिमेंटिक सर्च इंडेक्स बनाती है। यह Roo Code को केवल कीवर्ड के बजाय अर्थ के आधार पर संबंधित कोड खोजकर बड़े कोडबेस को बेहतर तरीके से समझने और नेविगेट करने में सक्षम बनाता है।", - "providerLabel": "एम्बेडिंग प्रदाता", - "selectProviderPlaceholder": "प्रदाता चुनें", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI संगत", - "openaiCompatibleBaseUrlLabel": "आधार URL:", - "openaiCompatibleApiKeyLabel": "API कुंजी:", - "openaiCompatibleModelDimensionLabel": "एम्बेडिंग आयाम:", - "openaiCompatibleModelDimensionPlaceholder": "उदा., 1536", - "openaiCompatibleModelDimensionDescription": "आपके मॉडल के लिए एम्बेडिंग आयाम (आउटपुट साइज)। इस मान के लिए अपने प्रदाता के दस्तावेज़ीकरण की जांच करें। सामान्य मान: 384, 768, 1536, 3072।", - "openaiKeyLabel": "OpenAI कुंजी:", - "modelLabel": "मॉडल", - "selectModelPlaceholder": "मॉडल चुनें", - "ollamaUrlLabel": "Ollama URL:", - "qdrantUrlLabel": "Qdrant URL", - "qdrantKeyLabel": "Qdrant कुंजी:", - "advancedConfigLabel": "उन्नत कॉन्फ़िगरेशन", - "searchMinScoreLabel": "खोज स्कोर थ्रेसहोल्ड", - "searchMinScoreDescription": "खोज परिणामों के लिए आवश्यक न्यूनतम समानता स्कोर (0.0-1.0)। कम मान अधिक परिणाम लौटाते हैं लेकिन कम प्रासंगिक हो सकते हैं। उच्च मान कम लेकिन अधिक प्रासंगिक परिणाम लौटाते हैं।", - "searchMinScoreResetTooltip": "डिफ़ॉल्ट मान पर रीसेट करें (0.4)", - "startIndexingButton": "इंडेक्सिंग शुरू करें", - "clearIndexDataButton": "इंडेक्स डेटा साफ़ करें", - "unsavedSettingsMessage": "इंडेक्सिंग प्रक्रिया शुरू करने से पहले कृपया अपनी सेटिंग्स सहेजें।", - "clearDataDialog": { - "title": "क्या आप सुनिश्चित हैं?", - "description": "यह क्रिया पूर्ववत नहीं की जा सकती। यह आपके कोडबेस इंडेक्स डेटा को स्थायी रूप से हटा देगी।", - "cancelButton": "रद्द करें", - "confirmButton": "डेटा साफ़ करें" - } - }, "codeIndex": { "title": "कोडबेस इंडेक्सिंग", "enableLabel": "कोडबेस इंडेक्सिंग सक्षम करें", diff --git a/webview-ui/src/i18n/locales/id/settings.json b/webview-ui/src/i18n/locales/id/settings.json index feb48ba3e9..7052645f60 100644 --- a/webview-ui/src/i18n/locales/id/settings.json +++ b/webview-ui/src/i18n/locales/id/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Konfigurasi support prompt yang digunakan untuk aksi cepat seperti meningkatkan prompt, menjelaskan kode, dan memperbaiki masalah. Prompt ini membantu Roo memberikan bantuan yang lebih baik untuk tugas pengembangan umum." }, - "codeIndex": { - "title": "Pengindeksan Codebase", - "enableLabel": "Aktifkan Pengindeksan Codebase", - "enableDescription": "<0>Pengindeksan Codebase adalah fitur eksperimental yang membuat indeks pencarian semantik dari proyek kamu menggunakan AI embeddings. Ini memungkinkan Roo Code untuk lebih memahami dan menavigasi codebase besar dengan menemukan kode yang relevan berdasarkan makna daripada hanya kata kunci.", - "providerLabel": "Provider Embeddings", - "selectProviderPlaceholder": "Pilih provider", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI Compatible", - "openaiKeyLabel": "OpenAI Key:", - "openaiCompatibleBaseUrlLabel": "Base URL:", - "openaiCompatibleApiKeyLabel": "API Key:", - "openaiCompatibleModelDimensionLabel": "Dimensi Embedding:", - "openaiCompatibleModelDimensionPlaceholder": "misalnya, 1536", - "openaiCompatibleModelDimensionDescription": "Dimensi embedding (ukuran output) untuk model kamu. Periksa dokumentasi provider kamu untuk nilai ini. Nilai umum: 384, 768, 1536, 3072.", - "modelLabel": "Model", - "selectModelPlaceholder": "Pilih model", - "ollamaUrlLabel": "Ollama URL:", - "qdrantUrlLabel": "Qdrant URL", - "qdrantKeyLabel": "Qdrant Key:", - "advancedConfigLabel": "Konfigurasi Lanjutan", - "searchMinScoreLabel": "Ambang Batas Skor Pencarian", - "searchMinScoreDescription": "Skor kesamaan minimum (0.0-1.0) yang diperlukan untuk hasil pencarian. Nilai yang lebih rendah mengembalikan lebih banyak hasil tetapi mungkin kurang relevan. Nilai yang lebih tinggi mengembalikan lebih sedikit hasil tetapi lebih relevan.", - "searchMinScoreResetTooltip": "Reset ke nilai default (0.4)", - "startIndexingButton": "Mulai Pengindeksan", - "clearIndexDataButton": "Hapus Data Indeks", - "unsavedSettingsMessage": "Silakan simpan pengaturan kamu sebelum memulai proses pengindeksan.", - "clearDataDialog": { - "title": "Apakah kamu yakin?", - "description": "Tindakan ini tidak dapat dibatalkan. Ini akan menghapus data indeks codebase kamu secara permanen.", - "cancelButton": "Batal", - "confirmButton": "Hapus Data" - } - }, "codeIndex": { "title": "Pengindeksan Basis Kode", "enableLabel": "Aktifkan Pengindeksan Basis Kode", diff --git a/webview-ui/src/i18n/locales/it/settings.json b/webview-ui/src/i18n/locales/it/settings.json index a4c1ddcd7a..9b338a5753 100644 --- a/webview-ui/src/i18n/locales/it/settings.json +++ b/webview-ui/src/i18n/locales/it/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Configura i prompt di supporto utilizzati per azioni rapide come il miglioramento dei prompt, la spiegazione del codice e la risoluzione dei problemi. Questi prompt aiutano Roo a fornire una migliore assistenza per le attività di sviluppo comuni." }, - "codeIndex": { - "title": "Indicizzazione del codice", - "enableLabel": "Abilita indicizzazione del codice", - "enableDescription": "<0>L'indicizzazione del codice è una funzionalità sperimentale che crea un indice di ricerca semantica del tuo progetto utilizzando embedding AI. Questo permette a Roo Code di comprendere meglio e navigare grandi basi di codice trovando codice rilevante basato sul significato piuttosto che solo su parole chiave.", - "providerLabel": "Fornitore di embedding", - "selectProviderPlaceholder": "Seleziona fornitore", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "Compatibile con OpenAI", - "openaiCompatibleBaseUrlLabel": "URL di base:", - "openaiCompatibleApiKeyLabel": "Chiave API:", - "openaiCompatibleModelDimensionLabel": "Dimensione Embedding:", - "openaiCompatibleModelDimensionPlaceholder": "es., 1536", - "openaiCompatibleModelDimensionDescription": "La dimensione dell'embedding (dimensione di output) per il tuo modello. Controlla la documentazione del tuo provider per questo valore. Valori comuni: 384, 768, 1536, 3072.", - "openaiKeyLabel": "Chiave OpenAI:", - "modelLabel": "Modello", - "selectModelPlaceholder": "Seleziona modello", - "ollamaUrlLabel": "URL Ollama:", - "qdrantUrlLabel": "URL Qdrant", - "qdrantKeyLabel": "Chiave Qdrant:", - "advancedConfigLabel": "Configurazione avanzata", - "searchMinScoreLabel": "Soglia punteggio di ricerca", - "searchMinScoreDescription": "Punteggio minimo di somiglianza (0.0-1.0) richiesto per i risultati della ricerca. Valori più bassi restituiscono più risultati ma potrebbero essere meno pertinenti. Valori più alti restituiscono meno risultati ma più pertinenti.", - "searchMinScoreResetTooltip": "Ripristina al valore predefinito (0.4)", - "startIndexingButton": "Avvia indicizzazione", - "clearIndexDataButton": "Cancella dati indice", - "unsavedSettingsMessage": "Per favore salva le tue impostazioni prima di avviare il processo di indicizzazione.", - "clearDataDialog": { - "title": "Sei sicuro?", - "description": "Questa azione non può essere annullata. Eliminerà permanentemente i dati di indice del tuo codice.", - "cancelButton": "Annulla", - "confirmButton": "Cancella dati" - } - }, "codeIndex": { "title": "Indicizzazione della base di codice", "enableLabel": "Abilita l'indicizzazione della base di codice", diff --git a/webview-ui/src/i18n/locales/ja/settings.json b/webview-ui/src/i18n/locales/ja/settings.json index 2d5ee1ab6a..d081d269fc 100644 --- a/webview-ui/src/i18n/locales/ja/settings.json +++ b/webview-ui/src/i18n/locales/ja/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "プロンプトの強化、コードの説明、問題の修正などの迅速なアクションに使用されるサポートプロンプトを設定します。これらのプロンプトは、Rooが一般的な開発タスクでより良いサポートを提供するのに役立ちます。" }, - "codeIndex": { - "title": "コードベースのインデックス作成", - "enableLabel": "コードベースのインデックス作成を有効化", - "enableDescription": "<0>コードベースのインデックス作成は、AIエンベディングを使用してプロジェクトのセマンティック検索インデックスを作成する実験的機能です。これにより、Roo Codeは単なるキーワードではなく意味に基づいて関連するコードを見つけることで、大規模なコードベースをより良く理解し、ナビゲートできるようになります。", - "providerLabel": "埋め込みプロバイダー", - "selectProviderPlaceholder": "プロバイダーを選択", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI互換", - "openaiCompatibleBaseUrlLabel": "ベースURL：", - "openaiCompatibleApiKeyLabel": "APIキー：", - "openaiCompatibleModelDimensionLabel": "埋め込みディメンション：", - "openaiCompatibleModelDimensionPlaceholder": "例：1536", - "openaiCompatibleModelDimensionDescription": "モデルの埋め込みディメンション（出力サイズ）。この値についてはプロバイダーのドキュメントを確認してください。一般的な値：384、768、1536、3072。", - "openaiKeyLabel": "OpenAIキー：", - "modelLabel": "モデル", - "selectModelPlaceholder": "モデルを選択", - "ollamaUrlLabel": "Ollama URL：", - "qdrantUrlLabel": "Qdrant URL", - "qdrantKeyLabel": "Qdrantキー：", - "advancedConfigLabel": "詳細設定", - "searchMinScoreLabel": "検索スコアのしきい値", - "searchMinScoreDescription": "検索結果に必要な最小類似度スコア（0.0-1.0）。値を低くするとより多くの結果が返されますが、関連性が低くなる可能性があります。値を高くすると返される結果は少なくなりますが、より関連性が高くなります。", - "searchMinScoreResetTooltip": "デフォルト値（0.4）にリセット", - "startIndexingButton": "インデックス作成を開始", - "clearIndexDataButton": "インデックスデータをクリア", - "unsavedSettingsMessage": "インデックス作成プロセスを開始する前に設定を保存してください。", - "clearDataDialog": { - "title": "本当によろしいですか？", - "description": "この操作は元に戻せません。コードベースのインデックスデータが完全に削除されます。", - "cancelButton": "キャンセル", - "confirmButton": "データをクリア" - } - }, "codeIndex": { "title": "コードベースのインデックス作成", "enableLabel": "コードベースのインデックス作成を有効にする", diff --git a/webview-ui/src/i18n/locales/ko/settings.json b/webview-ui/src/i18n/locales/ko/settings.json index c587e8dfa9..7da3f67bc8 100644 --- a/webview-ui/src/i18n/locales/ko/settings.json +++ b/webview-ui/src/i18n/locales/ko/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "프롬프트 향상, 코드 설명, 문제 해결과 같은 빠른 작업에 사용되는 지원 프롬프트를 구성합니다. 이러한 프롬프트는 Roo가 일반적인 개발 작업에 대해 더 나은 지원을 제공하는 데 도움이 됩니다." }, - "codeIndex": { - "title": "코드베이스 인덱싱", - "enableLabel": "코드베이스 인덱싱 활성화", - "enableDescription": "<0>코드베이스 인덱싱은 AI 임베딩을 사용하여 프로젝트의 의미론적 검색 인덱스를 생성하는 실험적 기능입니다. 이를 통해 Roo Code는 단순한 키워드가 아닌 의미를 기반으로 관련 코드를 찾아 대규모 코드베이스를 더 잘 이해하고 탐색할 수 있습니다.", - "providerLabel": "임베딩 제공자", - "selectProviderPlaceholder": "제공자 선택", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI 호환", - "openaiCompatibleBaseUrlLabel": "기본 URL:", - "openaiCompatibleApiKeyLabel": "API 키:", - "openaiCompatibleModelDimensionLabel": "임베딩 차원:", - "openaiCompatibleModelDimensionPlaceholder": "예: 1536", - "openaiCompatibleModelDimensionDescription": "모델의 임베딩 차원(출력 크기)입니다. 이 값에 대해서는 제공업체의 문서를 확인하세요. 일반적인 값: 384, 768, 1536, 3072.", - "openaiKeyLabel": "OpenAI 키:", - "modelLabel": "모델", - "selectModelPlaceholder": "모델 선택", - "ollamaUrlLabel": "Ollama URL:", - "qdrantUrlLabel": "Qdrant URL", - "qdrantKeyLabel": "Qdrant 키:", - "advancedConfigLabel": "고급 구성", - "searchMinScoreLabel": "검색 점수 임계값", - "searchMinScoreDescription": "검색 결과에 필요한 최소 유사도 점수(0.0-1.0). 값이 낮을수록 더 많은 결과가 반환되지만 관련성이 떨어질 수 있습니다. 값이 높을수록 결과는 적지만 관련성이 높은 결과가 반환됩니다.", - "searchMinScoreResetTooltip": "기본값(0.4)으로 재설정", - "startIndexingButton": "인덱싱 시작", - "clearIndexDataButton": "인덱스 데이터 지우기", - "unsavedSettingsMessage": "인덱싱 프로세스를 시작하기 전에 설정을 저장해 주세요.", - "clearDataDialog": { - "title": "확실합니까?", - "description": "이 작업은 취소할 수 없습니다. 코드베이스 인덱스 데이터가 영구적으로 삭제됩니다.", - "cancelButton": "취소", - "confirmButton": "데이터 지우기" - } - }, "codeIndex": { "title": "코드베이스 인덱싱", "enableLabel": "코드베이스 인덱싱 활성화", diff --git a/webview-ui/src/i18n/locales/nl/settings.json b/webview-ui/src/i18n/locales/nl/settings.json index 543630edcf..5eea0d04cb 100644 --- a/webview-ui/src/i18n/locales/nl/settings.json +++ b/webview-ui/src/i18n/locales/nl/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Configureer ondersteuningsprompts die worden gebruikt voor snelle acties zoals het verbeteren van prompts, het uitleggen van code en het oplossen van problemen. Deze prompts helpen Roo om betere ondersteuning te bieden voor veelvoorkomende ontwikkelingstaken." }, - "codeIndex": { - "title": "Codebase indexering", - "enableLabel": "Codebase indexering inschakelen", - "enableDescription": "<0>Codebase indexering is een experimentele functie die een semantische zoekindex van je project creëert met behulp van AI-embeddings. Dit stelt Roo Code in staat om grote codebases beter te begrijpen en te navigeren door relevante code te vinden op basis van betekenis in plaats van alleen trefwoorden.", - "providerLabel": "Embeddings provider", - "selectProviderPlaceholder": "Selecteer provider", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI-compatibel", - "openaiCompatibleBaseUrlLabel": "Basis-URL:", - "openaiCompatibleApiKeyLabel": "API-sleutel:", - "openaiCompatibleModelDimensionLabel": "Embedding Dimensie:", - "openaiCompatibleModelDimensionPlaceholder": "bijv., 1536", - "openaiCompatibleModelDimensionDescription": "De embedding dimensie (uitvoergrootte) voor uw model. Controleer de documentatie van uw provider voor deze waarde. Veelvoorkomende waarden: 384, 768, 1536, 3072.", - "openaiKeyLabel": "OpenAI-sleutel:", - "modelLabel": "Model", - "selectModelPlaceholder": "Selecteer model", - "ollamaUrlLabel": "Ollama URL:", - "qdrantUrlLabel": "Qdrant URL", - "qdrantKeyLabel": "Qdrant-sleutel:", - "advancedConfigLabel": "Geavanceerde configuratie", - "searchMinScoreLabel": "Zoekscore drempel", - "searchMinScoreDescription": "Minimale overeenkomstscore (0.0-1.0) vereist voor zoekresultaten. Lagere waarden leveren meer resultaten op, maar zijn mogelijk minder relevant. Hogere waarden leveren minder, maar relevantere resultaten op.", - "searchMinScoreResetTooltip": "Reset naar standaardwaarde (0.4)", - "startIndexingButton": "Indexering starten", - "clearIndexDataButton": "Indexgegevens wissen", - "unsavedSettingsMessage": "Sla je instellingen op voordat je het indexeringsproces start.", - "clearDataDialog": { - "title": "Weet je het zeker?", - "description": "Deze actie kan niet ongedaan worden gemaakt. Dit zal je codebase-indexgegevens permanent verwijderen.", - "cancelButton": "Annuleren", - "confirmButton": "Gegevens wissen" - } - }, "codeIndex": { "title": "Codebase-indexering", "enableLabel": "Codebase-indexering inschakelen", diff --git a/webview-ui/src/i18n/locales/pl/settings.json b/webview-ui/src/i18n/locales/pl/settings.json index f028282c33..1ee19716e2 100644 --- a/webview-ui/src/i18n/locales/pl/settings.json +++ b/webview-ui/src/i18n/locales/pl/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Skonfiguruj podpowiedzi wsparcia używane do szybkich działań, takich jak ulepszanie podpowiedzi, wyjaśnianie kodu i rozwiązywanie problemów. Te podpowiedzi pomagają Roo zapewnić lepsze wsparcie dla typowych zadań programistycznych." }, - "codeIndex": { - "title": "Indeksowanie kodu", - "enableLabel": "Włącz indeksowanie kodu", - "enableDescription": "<0>Indeksowanie kodu to eksperymentalna funkcja, która tworzy semantyczny indeks wyszukiwania Twojego projektu przy użyciu osadzeń AI. Umożliwia to Roo Code lepsze zrozumienie i nawigację po dużych bazach kodu poprzez znajdowanie odpowiedniego kodu na podstawie znaczenia, a nie tylko słów kluczowych.", - "providerLabel": "Dostawca osadzania", - "selectProviderPlaceholder": "Wybierz dostawcę", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "Kompatybilny z OpenAI", - "openaiCompatibleBaseUrlLabel": "Bazowy URL:", - "openaiCompatibleApiKeyLabel": "Klucz API:", - "openaiCompatibleModelDimensionLabel": "Wymiar Embeddingu:", - "openaiCompatibleModelDimensionPlaceholder": "np., 1536", - "openaiCompatibleModelDimensionDescription": "Wymiar embeddingu (rozmiar wyjściowy) dla twojego modelu. Sprawdź dokumentację swojego dostawcy, aby uzyskać tę wartość. Typowe wartości: 384, 768, 1536, 3072.", - "openaiKeyLabel": "Klucz OpenAI:", - "modelLabel": "Model", - "selectModelPlaceholder": "Wybierz model", - "ollamaUrlLabel": "URL Ollama:", - "qdrantUrlLabel": "URL Qdrant", - "qdrantKeyLabel": "Klucz Qdrant:", - "advancedConfigLabel": "Konfiguracja zaawansowana", - "searchMinScoreLabel": "Próg wyniku wyszukiwania", - "searchMinScoreDescription": "Minimalny wynik podobieństwa (0.0-1.0) wymagany dla wyników wyszukiwania. Niższe wartości zwracają więcej wyników, ale mogą być mniej trafne. Wyższe wartości zwracają mniej wyników, ale bardziej trafnych.", - "searchMinScoreResetTooltip": "Zresetuj do wartości domyślnej (0.4)", - "startIndexingButton": "Rozpocznij indeksowanie", - "clearIndexDataButton": "Wyczyść dane indeksu", - "unsavedSettingsMessage": "Zapisz swoje ustawienia przed rozpoczęciem procesu indeksowania.", - "clearDataDialog": { - "title": "Czy jesteś pewien?", - "description": "Tej akcji nie można cofnąć. Spowoduje to trwałe usunięcie danych indeksu Twojego kodu.", - "cancelButton": "Anuluj", - "confirmButton": "Wyczyść dane" - } - }, "codeIndex": { "title": "Indeksowanie bazy kodu", "enableLabel": "Włącz indeksowanie bazy kodu", diff --git a/webview-ui/src/i18n/locales/pt-BR/settings.json b/webview-ui/src/i18n/locales/pt-BR/settings.json index c6cfb2dae7..3ccd609104 100644 --- a/webview-ui/src/i18n/locales/pt-BR/settings.json +++ b/webview-ui/src/i18n/locales/pt-BR/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Configure prompts de suporte usados para ações rápidas como melhorar prompts, explicar código e corrigir problemas. Esses prompts ajudam o Roo a fornecer melhor assistência para tarefas comuns de desenvolvimento." }, - "codeIndex": { - "title": "Indexação de Código", - "enableLabel": "Ativar Indexação de Código", - "enableDescription": "<0>Indexação de Código é um recurso experimental que cria um índice de busca semântica do seu projeto usando embeddings de IA. Isso permite ao Roo Code entender melhor e navegar grandes bases de código encontrando código relevante baseado em significado ao invés de apenas palavras-chave.", - "providerLabel": "Provedor de Embeddings", - "selectProviderPlaceholder": "Selecionar provedor", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "Compatível com OpenAI", - "openaiCompatibleBaseUrlLabel": "URL Base:", - "openaiCompatibleApiKeyLabel": "Chave de API:", - "openaiCompatibleModelDimensionLabel": "Dimensão de Embedding:", - "openaiCompatibleModelDimensionPlaceholder": "ex., 1536", - "openaiCompatibleModelDimensionDescription": "A dimensão de embedding (tamanho de saída) para seu modelo. Verifique a documentação do seu provedor para este valor. Valores comuns: 384, 768, 1536, 3072.", - "openaiKeyLabel": "Chave OpenAI:", - "modelLabel": "Modelo", - "selectModelPlaceholder": "Selecionar modelo", - "ollamaUrlLabel": "URL Ollama:", - "qdrantUrlLabel": "URL Qdrant", - "qdrantKeyLabel": "Chave Qdrant:", - "advancedConfigLabel": "Configuração Avançada", - "searchMinScoreLabel": "Limite de pontuação de busca", - "searchMinScoreDescription": "Pontuação mínima de similaridade (0.0-1.0) necessária para os resultados da busca. Valores mais baixos retornam mais resultados, mas podem ser menos relevantes. Valores mais altos retornam menos resultados, mas mais relevantes.", - "searchMinScoreResetTooltip": "Redefinir para o valor padrão (0.4)", - "startIndexingButton": "Iniciar Indexação", - "clearIndexDataButton": "Limpar Dados de Índice", - "unsavedSettingsMessage": "Por favor, salve suas configurações antes de iniciar o processo de indexação.", - "clearDataDialog": { - "title": "Tem certeza?", - "description": "Esta ação não pode ser desfeita. Isso excluirá permanentemente os dados de índice da sua base de código.", - "cancelButton": "Cancelar", - "confirmButton": "Limpar Dados" - } - }, "codeIndex": { "title": "Indexação da base de código", "enableLabel": "Habilitar a indexação da base de código", diff --git a/webview-ui/src/i18n/locales/ru/settings.json b/webview-ui/src/i18n/locales/ru/settings.json index 1b55f17ce1..0c0e89686d 100644 --- a/webview-ui/src/i18n/locales/ru/settings.json +++ b/webview-ui/src/i18n/locales/ru/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Настройте промпты поддержки, используемые для быстрых действий, таких как улучшение промптов, объяснение кода и исправление проблем. Эти промпты помогают Roo обеспечить лучшую поддержку для общих задач разработки." }, - "codeIndex": { - "title": "Индексация кодовой базы", - "enableLabel": "Включить индексацию кодовой базы", - "enableDescription": "<0>Индексация кодовой базы — это экспериментальная функция, которая создает семантический поисковый индекс вашего проекта с использованием ИИ-эмбеддингов. Это позволяет Roo Code лучше понимать и навигировать по большим кодовым базам, находя релевантный код на основе смысла, а не только ключевых слов.", - "providerLabel": "Провайдер эмбеддингов", - "selectProviderPlaceholder": "Выберите провайдера", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI-совместимый", - "openaiCompatibleBaseUrlLabel": "Базовый URL:", - "openaiCompatibleApiKeyLabel": "Ключ API:", - "openaiCompatibleModelDimensionLabel": "Размерность эмбеддинга:", - "openaiCompatibleModelDimensionPlaceholder": "напр., 1536", - "openaiCompatibleModelDimensionDescription": "Размерность эмбеддинга (размер выходных данных) для вашей модели. Проверьте документацию вашего провайдера для этого значения. Распространенные значения: 384, 768, 1536, 3072.", - "openaiKeyLabel": "Ключ OpenAI:", - "modelLabel": "Модель", - "selectModelPlaceholder": "Выберите модель", - "ollamaUrlLabel": "URL Ollama:", - "qdrantUrlLabel": "URL Qdrant", - "qdrantKeyLabel": "Ключ Qdrant:", - "advancedConfigLabel": "Расширенная конфигурация", - "searchMinScoreLabel": "Порог оценки поиска", - "searchMinScoreDescription": "Минимальный балл сходства (0.0-1.0), необходимый для результатов поиска. Более низкие значения возвращают больше результатов, но они могут быть менее релевантными. Более высокие значения возвращают меньше результатов, но более релевантных.", - "searchMinScoreResetTooltip": "Сбросить к значению по умолчанию (0.4)", - "startIndexingButton": "Начать индексацию", - "clearIndexDataButton": "Очистить данные индекса", - "unsavedSettingsMessage": "Пожалуйста, сохрани настройки перед запуском процесса индексации.", - "clearDataDialog": { - "title": "Вы уверены?", - "description": "Это действие нельзя отменить. Оно навсегда удалит данные индекса вашей кодовой базы.", - "cancelButton": "Отмена", - "confirmButton": "Очистить данные" - } - }, "codeIndex": { "title": "Индексирование кодовой базы", "enableLabel": "Включить индексирование кодовой базы", diff --git a/webview-ui/src/i18n/locales/tr/settings.json b/webview-ui/src/i18n/locales/tr/settings.json index d3f9602273..6ec5183d47 100644 --- a/webview-ui/src/i18n/locales/tr/settings.json +++ b/webview-ui/src/i18n/locales/tr/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Prompt geliştirme, kod açıklama ve sorun çözme gibi hızlı eylemler için kullanılan destek promptlarını yapılandırın. Bu promptlar, Roo'nun yaygın geliştirme görevleri için daha iyi destek sağlamasına yardımcı olur." }, - "codeIndex": { - "title": "Kod Tabanı İndeksleme", - "enableLabel": "Kod Tabanı İndekslemeyi Etkinleştir", - "enableDescription": "<0>Kod Tabanı İndeksleme, AI gömme teknolojisini kullanarak projenizin semantik arama indeksini oluşturan deneysel bir özelliktir. Bu, Roo Code'un sadece anahtar kelimeler yerine anlam temelinde ilgili kodu bularak büyük kod tabanlarını daha iyi anlamasını ve gezinmesini sağlar.", - "providerLabel": "Gömme Sağlayıcısı", - "selectProviderPlaceholder": "Sağlayıcı seç", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI Uyumlu", - "openaiCompatibleBaseUrlLabel": "Temel URL:", - "openaiCompatibleApiKeyLabel": "API Anahtarı:", - "openaiCompatibleModelDimensionLabel": "Gömme Boyutu:", - "openaiCompatibleModelDimensionPlaceholder": "örn., 1536", - "openaiCompatibleModelDimensionDescription": "Modeliniz için gömme boyutu (çıktı boyutu). Bu değer için sağlayıcınızın belgelerine bakın. Yaygın değerler: 384, 768, 1536, 3072.", - "openaiKeyLabel": "OpenAI Anahtarı:", - "modelLabel": "Model", - "selectModelPlaceholder": "Model seç", - "ollamaUrlLabel": "Ollama URL:", - "qdrantUrlLabel": "Qdrant URL", - "qdrantKeyLabel": "Qdrant Anahtarı:", - "advancedConfigLabel": "Gelişmiş Yapılandırma", - "searchMinScoreLabel": "Arama Skoru Eşiği", - "searchMinScoreDescription": "Arama sonuçları için gereken minimum benzerlik puanı (0.0-1.0). Düşük değerler daha fazla sonuç döndürür ancak daha az alakalı olabilir. Yüksek değerler daha az ancak daha alakalı sonuçlar döndürür.", - "searchMinScoreResetTooltip": "Varsayılan değere sıfırla (0.4)", - "startIndexingButton": "İndekslemeyi Başlat", - "clearIndexDataButton": "İndeks Verilerini Temizle", - "unsavedSettingsMessage": "İndeksleme işlemini başlatmadan önce lütfen ayarlarını kaydet.", - "clearDataDialog": { - "title": "Emin misiniz?", - "description": "Bu işlem geri alınamaz. Bu, kod tabanı indeks verilerinizi kalıcı olarak silecektir.", - "cancelButton": "İptal", - "confirmButton": "Verileri Temizle" - } - }, "codeIndex": { "title": "Kod Tabanı İndeksleme", "enableLabel": "Kod Tabanı İndekslemeyi Etkinleştir", diff --git a/webview-ui/src/i18n/locales/vi/settings.json b/webview-ui/src/i18n/locales/vi/settings.json index de5b62f6e6..fc8deff596 100644 --- a/webview-ui/src/i18n/locales/vi/settings.json +++ b/webview-ui/src/i18n/locales/vi/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "Cấu hình các lời nhắc hỗ trợ được sử dụng cho các hành động nhanh như cải thiện lời nhắc, giải thích mã và khắc phục sự cố. Những lời nhắc này giúp Roo cung cấp hỗ trợ tốt hơn cho các tác vụ phát triển phổ biến." }, - "codeIndex": { - "title": "Lập chỉ mục mã nguồn", - "enableLabel": "Bật lập chỉ mục mã nguồn", - "enableDescription": "<0>Lập chỉ mục mã nguồn là một tính năng thử nghiệm tạo ra chỉ mục tìm kiếm ngữ nghĩa cho dự án của bạn bằng cách sử dụng AI embeddings. Điều này cho phép Roo Code hiểu rõ hơn và điều hướng các codebase lớn bằng cách tìm mã liên quan dựa trên ý nghĩa thay vì chỉ từ khóa.", - "providerLabel": "Nhà cung cấp nhúng", - "selectProviderPlaceholder": "Chọn nhà cung cấp", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "Tương thích OpenAI", - "openaiCompatibleBaseUrlLabel": "URL cơ sở:", - "openaiCompatibleApiKeyLabel": "Khóa API:", - "openaiCompatibleModelDimensionLabel": "Kích thước Embedding:", - "openaiCompatibleModelDimensionPlaceholder": "vd., 1536", - "openaiCompatibleModelDimensionDescription": "Kích thước embedding (kích thước đầu ra) cho mô hình của bạn. Kiểm tra tài liệu của nhà cung cấp để biết giá trị này. Giá trị phổ biến: 384, 768, 1536, 3072.", - "openaiKeyLabel": "Khóa OpenAI:", - "modelLabel": "Mô hình", - "selectModelPlaceholder": "Chọn mô hình", - "ollamaUrlLabel": "URL Ollama:", - "qdrantUrlLabel": "URL Qdrant", - "qdrantKeyLabel": "Khóa Qdrant:", - "advancedConfigLabel": "Cấu hình nâng cao", - "searchMinScoreLabel": "Ngưỡng điểm tìm kiếm", - "searchMinScoreDescription": "Điểm tương đồng tối thiểu (0.0-1.0) cần thiết cho kết quả tìm kiếm. Giá trị thấp hơn trả về nhiều kết quả hơn nhưng có thể kém liên quan hơn. Giá trị cao hơn trả về ít kết quả hơn nhưng có liên quan hơn.", - "searchMinScoreResetTooltip": "Đặt lại về giá trị mặc định (0.4)", - "startIndexingButton": "Bắt đầu lập chỉ mục", - "clearIndexDataButton": "Xóa dữ liệu chỉ mục", - "unsavedSettingsMessage": "Vui lòng lưu cài đặt của bạn trước khi bắt đầu quá trình lập chỉ mục.", - "clearDataDialog": { - "title": "Bạn có chắc không?", - "description": "Hành động này không thể hoàn tác. Điều này sẽ xóa vĩnh viễn dữ liệu chỉ mục mã nguồn của bạn.", - "cancelButton": "Hủy", - "confirmButton": "Xóa dữ liệu" - } - }, "codeIndex": { "title": "Chỉ mục hóa cơ sở mã", "enableLabel": "Bật chỉ mục hóa cơ sở mã", diff --git a/webview-ui/src/i18n/locales/zh-CN/settings.json b/webview-ui/src/i18n/locales/zh-CN/settings.json index d50959fa2f..802d2d294e 100644 --- a/webview-ui/src/i18n/locales/zh-CN/settings.json +++ b/webview-ui/src/i18n/locales/zh-CN/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "配置用于快速操作的支持提示词，如增强提示词、解释代码和修复问题。这些提示词帮助 Roo 为常见开发任务提供更好的支持。" }, - "codeIndex": { - "title": "代码库索引", - "enableLabel": "启用代码库索引", - "enableDescription": "<0>代码库索引是一个实验性功能，使用 AI 嵌入为您的项目创建语义搜索索引。这使 Roo Code 能够通过基于含义而非仅仅关键词来查找相关代码，从而更好地理解和导航大型代码库。", - "providerLabel": "嵌入提供商", - "selectProviderPlaceholder": "选择提供商", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI 兼容", - "openaiCompatibleBaseUrlLabel": "基础 URL：", - "openaiCompatibleApiKeyLabel": "API 密钥：", - "openaiCompatibleModelDimensionLabel": "嵌入维度：", - "openaiCompatibleModelDimensionPlaceholder": "例如，1536", - "openaiCompatibleModelDimensionDescription": "模型的嵌入维度（输出大小）。请查阅您的提供商文档获取此值。常见值：384、768、1536、3072。", - "openaiKeyLabel": "OpenAI 密钥：", - "modelLabel": "模型", - "selectModelPlaceholder": "选择模型", - "ollamaUrlLabel": "Ollama URL：", - "qdrantUrlLabel": "Qdrant URL", - "qdrantKeyLabel": "Qdrant 密钥：", - "advancedConfigLabel": "高级配置", - "searchMinScoreLabel": "搜索分数阈值", - "searchMinScoreDescription": "搜索结果所需的最低相似度分数（0.0-1.0）。较低的值返回更多结果，但可能不太相关。较高的值返回较少但更相关的结果。", - "searchMinScoreResetTooltip": "恢复默认值 (0.4)", - "startIndexingButton": "开始索引", - "clearIndexDataButton": "清除索引数据", - "unsavedSettingsMessage": "请先保存设置再开始索引过程。", - "clearDataDialog": { - "title": "确定要继续吗？", - "description": "此操作无法撤消。这将永久删除您的代码库索引数据。", - "cancelButton": "取消", - "confirmButton": "清除数据" - } - }, "codeIndex": { "title": "代码库索引", "enableLabel": "启用代码库索引", diff --git a/webview-ui/src/i18n/locales/zh-TW/settings.json b/webview-ui/src/i18n/locales/zh-TW/settings.json index d8bbc5ebc4..441a003d42 100644 --- a/webview-ui/src/i18n/locales/zh-TW/settings.json +++ b/webview-ui/src/i18n/locales/zh-TW/settings.json @@ -36,40 +36,6 @@ "prompts": { "description": "設定用於快速操作的支援提示詞，如增強提示詞、解釋程式碼和修復問題。這些提示詞幫助 Roo 為常見開發工作提供更好的支援。" }, - "codeIndex": { - "title": "程式碼庫索引", - "enableLabel": "啟用程式碼庫索引", - "enableDescription": "<0>程式碼庫索引是一個實驗性功能，使用 AI 嵌入為您的專案建立語義搜尋索引。這使 Roo Code 能夠透過基於含義而非僅僅關鍵詞來尋找相關程式碼，從而更好地理解和導覽大型程式碼庫。", - "providerLabel": "嵌入提供者", - "selectProviderPlaceholder": "選擇提供者", - "openaiProvider": "OpenAI", - "ollamaProvider": "Ollama", - "openaiCompatibleProvider": "OpenAI 相容", - "openaiCompatibleBaseUrlLabel": "基礎 URL：", - "openaiCompatibleApiKeyLabel": "API 金鑰：", - "openaiCompatibleModelDimensionLabel": "嵌入維度：", - "openaiCompatibleModelDimensionPlaceholder": "例如，1536", - "openaiCompatibleModelDimensionDescription": "模型的嵌入維度（輸出大小）。請查閱您的提供商文件獲取此值。常見值：384、768、1536、3072。", - "openaiKeyLabel": "OpenAI 金鑰：", - "modelLabel": "模型", - "selectModelPlaceholder": "選擇模型", - "ollamaUrlLabel": "Ollama URL：", - "qdrantUrlLabel": "Qdrant URL", - "qdrantKeyLabel": "Qdrant 金鑰：", - "advancedConfigLabel": "進階設定", - "searchMinScoreLabel": "搜尋分數閾值", - "searchMinScoreDescription": "搜尋結果所需的最低相似度分數（0.0-1.0）。較低的值會傳回更多結果，但可能較不相關。較高的值會傳回較少但更相關的結果。", - "searchMinScoreResetTooltip": "重設為預設值 (0.4)", - "startIndexingButton": "開始索引", - "clearIndexDataButton": "清除索引資料", - "unsavedSettingsMessage": "請先儲存設定再開始索引程序。", - "clearDataDialog": { - "title": "確定要繼續嗎？", - "description": "此操作無法復原。這將永久刪除您的程式碼庫索引資料。", - "cancelButton": "取消", - "confirmButton": "清除資料" - } - }, "codeIndex": { "title": "程式碼庫索引", "enableLabel": "啟用程式碼庫索引",