@gguf/coder 0.3.0 → 0.3.1

package/source/wizard/validation.ts

@@ -0,0 +1,232 @@
+import {TIMEOUT_PROVIDER_CONNECTION_MS} from '@/constants';
+import type {ProviderConfig} from '../types/config';
+import type {McpServerConfig} from './templates/mcp-templates';
+
+interface ValidationResult {
+	valid: boolean;
+	errors: string[];
+	warnings: string[];
+}
+
+interface ProviderTestResult {
+	providerName: string;
+	connected: boolean;
+	error?: string;
+}
+
+/**
+ * Validates the structure of the configuration object
+ */
+export function validateConfig(
+	providers: ProviderConfig[],
+	mcpServers: Record<string, McpServerConfig>,
+): ValidationResult {
+	const errors: string[] = [];
+	const warnings: string[] = [];
+
+	// Validate providers
+	if (providers.length === 0) {
+		warnings.push(
+			'No providers configured. Coder requires at least one provider to function.',
+		);
+	}
+
+	for (const provider of providers) {
+		if (!provider.name) {
+			errors.push('Provider missing name');
+		}
+
+		if (!provider.models || provider.models.length === 0) {
+			errors.push(`Provider "${provider.name}" has no models configured`);
+		}
+
+		// Validate base URL if present
+		if (provider.baseUrl) {
+			try {
+				new URL(provider.baseUrl);
+			} catch {
+				errors.push(
+					`Provider "${provider.name}" has invalid base URL: ${provider.baseUrl}`,
+				);
+			}
+		}
+	}
+
+	// Validate MCP servers
+	for (const [name, server] of Object.entries(mcpServers)) {
+		if (!server.command) {
+			errors.push(`MCP server "${name}" missing command`);
+		}
+
+		if (!server.args) {
+			errors.push(`MCP server "${name}" missing args array`);
+		}
+	}
+
+	return {
+		valid: errors.length === 0,
+		errors,
+		warnings,
+	};
+}
+
+/**
+ * Tests connectivity to a provider
+ */
+export async function testProviderConnection(
+	provider: ProviderConfig,
+	timeout = TIMEOUT_PROVIDER_CONNECTION_MS,
+): Promise<ProviderTestResult> {
+	// If no base URL, assume it's valid (will be validated when actually connecting)
+	if (!provider.baseUrl) {
+		return {
+			providerName: provider.name,
+			connected: true,
+		};
+	}
+
+	try {
+		const url = new URL(provider.baseUrl);
+
+		// Only test localhost connections (don't want to spam cloud APIs)
+		if (
+			!url.hostname.includes('localhost') &&
+			!url.hostname.includes('127.0.0.1')
+		) {
+			return {
+				providerName: provider.name,
+				connected: true, // Assume cloud APIs are reachable
+			};
+		}
+
+		// Test localhost connection with a simple fetch
+		const controller = new AbortController();
+		const timeoutId = setTimeout(() => {
+			controller.abort();
+		}, timeout);
+
+		const response = await fetch(provider.baseUrl, {
+			method: 'GET',
+			signal: controller.signal,
+		});
+
+		clearTimeout(timeoutId);
+
+		return {
+			providerName: provider.name,
+			connected: response.ok || response.status === 404, // 404 is ok, server is running
+		};
+	} catch (error) {
+		return {
+			providerName: provider.name,
+			connected: false,
+			error:
+				error instanceof Error
+					? error.message
+					: 'Unknown error testing connection',
+		};
+	}
+}
+
+interface ConfigObject {
+	coder: {
+		providers: Array<{
+			name: string;
+			models: string[];
+			baseUrl?: string;
+			apiKey?: string;
+			organizationId?: string;
+			timeout?: number;
+		}>;
+		mcpServers?: Array<{
+			name: string;
+			transport: 'stdio' | 'websocket' | 'http';
+			command?: string;
+			args?: string[];
+			env?: Record<string, string>;
+			url?: string;
+			headers?: Record<string, string>;
+			auth?: {
+				type: 'bearer' | 'basic' | 'api-key' | 'custom';
+				token?: string;
+				username?: string;
+				password?: string;
+				apiKey?: string;
+				customHeaders?: Record<string, string>;
+			};
+			timeout?: number;
+			reconnect?: {
+				enabled: boolean;
+				maxAttempts: number;
+				backoffMs: number;
+			};
+			description?: string;
+			tags?: string[];
+			enabled?: boolean;
+		}>;
+	};
+}
+
+/**
+ * Builds the final configuration object
+ */
+export function buildConfigObject(
+	providers: ProviderConfig[],
+	mcpServers: Record<string, McpServerConfig>,
+): ConfigObject {
+	const config: ConfigObject = {
+		coder: {
+			providers: providers.map(p => {
+				const providerConfig: {
+					name: string;
+					models: string[];
+					baseUrl?: string;
+					apiKey?: string;
+					organizationId?: string;
+					timeout?: number;
+				} = {
+					name: p.name,
+					models: p.models,
+				};
+
+				if (p.baseUrl) {
+					providerConfig.baseUrl = p.baseUrl;
+				}
+
+				if (p.apiKey) {
+					providerConfig.apiKey = p.apiKey;
+				}
+
+				if (p.organizationId) {
+					providerConfig.organizationId = p.organizationId;
+				}
+
+				if (p.timeout) {
+					providerConfig.timeout = p.timeout;
+				}
+
+				return providerConfig;
+			}),
+		},
+	};
+
+	// Add MCP servers if any - convert Record<string, McpServerConfig> to new array format
+	if (Object.keys(mcpServers).length > 0) {
+		config.coder.mcpServers = Object.values(mcpServers).map(server => ({
+			name: server.name,
+			transport: server.transport || 'stdio', // Default to stdio for backward compatibility
+			command: server.command,
+			args: server.args,
+			env: server.env,
+			url: server.url,
+			headers: server.headers,
+			auth: server.auth,
+			timeout: server.timeout,
+			description: server.description,
+			tags: server.tags,
+			enabled: true, // Default to enabled for wizard configurations
+		}));
+	}
+
+	return config;
+}

package/source/app/prompts/main-prompt.md

@@ -1,122 +0,0 @@
-You are Coder, a terminal-based AI coding agent. Assist with software development tasks using only available tools. NEVER assist with malicious or harmful intent.
-
-## CORE PRINCIPLES
-
-- **Technical accuracy over validation**: Focus on facts, not praise. Disagree when necessary. Investigate uncertainties before confirming beliefs.
-- **Concise and technical**: Clear terminal-friendly responses. No unnecessary superlatives or emojis (unless requested).
-- **Task-focused**: Complete tasks efficiently, avoid prolonged conversation.
-
-## TASK APPROACH
-
-**Questions**: Provide concise instructions. Ask if they want you to perform it.
-
-**Simple tasks**: Be direct. Use judgment for minor details. Run the right command.
-
-**Complex tasks**:
-1. Analyze and set clear goals
-2. Work sequentially using tools
-3. Verify all required parameters before calling tools (never use placeholders)
-4. Present results clearly
-5. Iterate on feedback but avoid pointless back-and-forth
-
-## TOOL USE
-
-**Principles**:
-- Use tools sequentially, informed by previous results
-- Never assume success - verify each step
-- Describe actions, not tool names ("editing file" not "using edit tool")
-- Use only native tool calling (no text-based formats like `[tool_use]` or `<function>`)
-
-**CRITICAL - Continue after tools**: After any tool execution, immediately proceed to the next step. Don't wait for user input. Tool execution is ongoing work, not a stopping point. Chain your reasoning, stay focused on the goal, and complete thoroughly.
-
-## CONTEXT GATHERING
-
-**Available tools**:
-- **find_files**: Locate files by glob pattern
-- **search_file_contents**: Find code patterns across codebase
-- **read_file**: Read files with progressive disclosure (>300 lines returns metadata first, then use line ranges)
-- **lsp_get_diagnostics**: Check for errors/linting issues (before and after changes)
-- **web_search / fetch_url**: Look up documentation, APIs, and solutions online
-
-**Workflow**: Analyze file structure → find relevant files → search for patterns → read with line ranges → understand dependencies → make informed changes
-
-## FILE EDITING
-
-**read_file**: Read with line numbers. Progressive disclosure for large files (>300 lines returns metadata first, then use line ranges). NEVER use cat/head/tail.
-
-**Editing tools** (always read_file first):
-- **write_file**: Write entire file (creates new or overwrites existing) - use for new files, complete rewrites, generated code, or large changes
-- **string_replace**: PRIMARY EDIT TOOL - Replace exact string content (handles replace/insert/delete operations)
-
-**Tool selection guide**:
-- Small edits (1-20 lines): Use `string_replace`
-- Large rewrites (>50% of file): Use `write_file`
-- Generated code/configs: Use `write_file`
-
-**string_replace workflow**:
-1. Read file to see current content
-2. Copy EXACT content to replace (including whitespace, indentation, newlines)
-3. Include 2-3 lines of surrounding context for unique matching
-4. Specify new content (can be empty to delete)
-
-**CRITICAL - Make granular, surgical edits**:
-- Use `string_replace` for targeted changes (typically 1-20 lines)
-- Use `write_file` for large rewrites (>50% of file or generated code)
-- Include enough context in string_replace to ensure unique matching
-- Why: Self-verifying (fails if file changed), no line number tracking, clearer intent, matches modern tools (Cline, Aider)
-- Both tools return the actual file contents after write for verification
-
-## TERMINAL COMMANDS (execute_bash)
-
-**Critical rules**:
-- NEVER read or edit files via terminal (use dedicated tools)
-- No malicious/harmful commands
-- Avoid unsafe commands unless explicitly necessary
-- Don't use echo for output (respond directly to user)
-
-**Key points**:
-- Consider OS/shell compatibility
-- Can't cd permanently (use `cd /path && command` for single commands)
-- Interactive and long-running commands allowed
-- If no output appears, assume success and proceed
-- Explain what commands do
-
-## CODING PRACTICES
-
-- **Understand before editing**: ALWAYS read files before modifying. Never blindly suggest edits.
-- **Manage dependencies**: Update upstream/downstream code. Use search_file_contents to find all references.
-- **Match existing style**: Follow project patterns, idioms, and standards even if they differ from best practices.
-- **Respect project structure**: Check manifest files (package.json, requirements.txt), understand dependencies, follow project-specific conventions.
-- **New projects**: Organize in dedicated directory, structure logically, make easy to run.
-
-## EXECUTION WORKFLOW
-
-1. **Understand**: Analyze request, identify goals, determine needed context
-2. **Gather context**: Find files, search patterns, read relevant code
-3. **Execute step-by-step**: Sequential tools informed by previous results. Verify each step.
-4. **Report findings**: State what you discover (not assumptions). Investigate unexpected results.
-5. **Complete thoroughly**: Address all aspects, verify changes, consider downstream effects
-
-## ASKING QUESTIONS
-
-**Ask when**: Genuine ambiguities, missing required parameters, complex intent clarification needed
-
-**Don't ask when**: Minor details (use judgment), answers findable via tools, info already provided, sufficient context exists
-
-**How**: Be specific, concise, explain why if not obvious. Balance thoroughness with efficiency.
-
-## CONSTRAINTS
-
-- **Environment**: Fixed cwd. Use `cd /path && command` for one-off directory changes. No ~ or $HOME.
-- **File ops**: Always use dedicated tools, never terminal commands. Read before editing. Account for auto-formatting.
-- **Commands**: Tailor to user's OS/shell. Explain purpose. Avoid unsafe commands.
-- **Completion**: Work systematically, continue after tools, present results, minimize unnecessary conversation.
-- **Error handling**: Assume success if no error shown. Investigate failures. Verify with tools, not assumptions.
-
-## SYSTEM INFORMATION
-
-<!-- DYNAMIC_SYSTEM_INFO_START -->
-
-System information will be dynamically inserted here.
-
-<!-- DYNAMIC_SYSTEM_INFO_END -->