@gguf/coder 0.2.9 → 0.3.1

package/source/app.spec.tsx

@@ -0,0 +1,244 @@
+import test from 'ava';
+import { isNonInteractiveModeComplete, shouldRenderWelcome } from './app';
+
+// Test non-interactive mode integration
+// These tests verify that the App component correctly handles non-interactive mode
+
+// ============================================================================
+// Non-Interactive Mode Behavior Tests
+// ============================================================================
+
+test('Should omit welcome banner in non-interactive mode', t => {
+	t.false(shouldRenderWelcome(true));
+	t.true(shouldRenderWelcome(false));
+});
+
+test('Non-interactive mode: only exits when run command is used', t => {
+	// The exit logic only triggers when nonInteractivePrompt is truthy.
+	// Based on cli.tsx, nonInteractivePrompt is only set when the 'run' command is used:
+	//
+	// const runCommandIndex = args.findIndex(arg => arg === 'run');
+	// if (runCommandIndex !== -1 && args[runCommandIndex + 1]) {
+	//   nonInteractivePrompt = promptArgs.join(' ');
+	// }
+	//
+	// The exit condition in app.tsx checks:
+	// if (nonInteractivePrompt && nonInteractiveSubmitted) { ... }
+	//
+	// This means:
+	// - `coder` - Normal interactive mode, no auto-exit (nonInteractivePrompt is undefined)
+	// - `coder run "prompt"` - Non-interactive mode, auto-exits after completion
+	// - `coder --some-flag` - Mode with custom args, no auto-exit (nonInteractivePrompt is undefined)
+
+	// Test that nonInteractivePrompt is undefined without 'run' command
+	const argsWithoutRun = ['--some-flag'];
+	const runIndex = argsWithoutRun.findIndex(arg => arg === 'run');
+	const promptWithoutRun =
+		runIndex !== -1 && argsWithoutRun[runIndex + 1]
+			? argsWithoutRun.slice(runIndex + 1).join(' ')
+			: undefined;
+	t.is(promptWithoutRun, undefined);
+
+	// Test that nonInteractivePrompt is set with 'run' command
+	const argsWithRun = ['run', 'create', 'a', 'file'];
+	const runIndexWithRun = argsWithRun.findIndex(arg => arg === 'run');
+	const promptWithRun =
+		runIndexWithRun !== -1 && argsWithRun[runIndexWithRun + 1]
+			? argsWithRun.slice(runIndexWithRun + 1).join(' ')
+			: undefined;
+	t.is(promptWithRun, 'create a file');
+
+	t.pass();
+});
+
+test('Non-interactive mode: exits when AI finishes processing prompt', t => {
+	// Test the exit condition logic by simulating the state checks
+	// This tests the actual logic that determines when to exit
+
+	// Simulate app state when AI has completed
+	const appStateComplete = {
+		isThinking: false,
+		isToolExecuting: false,
+		isBashExecuting: false,
+		isToolConfirmationMode: false,
+		isConversationComplete: true,
+		messages: [
+			{ role: 'user', content: 'test' },
+			{ role: 'assistant', content: 'response' },
+		],
+	};
+
+	const startTime = Date.now();
+	const maxExecutionTimeMs = 300000; // 5 minutes
+
+	const { shouldExit, reason } = isNonInteractiveModeComplete(
+		appStateComplete,
+		startTime,
+		maxExecutionTimeMs,
+	);
+
+	t.true(shouldExit, 'Should exit when AI has finished processing');
+	t.is(reason, 'complete', 'Exit reason should be complete');
+	t.true(
+		appStateComplete.isConversationComplete,
+		'Conversation should be marked complete',
+	);
+});
+
+test('Non-interactive mode: does NOT exit while AI is still processing', t => {
+	// Test that we don't exit prematurely while AI is thinking
+	const appStateThinking = {
+		isThinking: true, // Still generating response
+		isToolExecuting: false,
+		isBashExecuting: false,
+		isToolConfirmationMode: false,
+		isConversationComplete: false,
+		messages: [{ role: 'user', content: 'test' }],
+	};
+
+	const startTime = Date.now();
+	const maxExecutionTimeMs = 300000;
+
+	const { shouldExit } = isNonInteractiveModeComplete(
+		appStateThinking,
+		startTime,
+		maxExecutionTimeMs,
+	);
+
+	t.false(shouldExit, 'Should NOT exit while AI is thinking');
+});
+
+test('Non-interactive mode: does NOT exit while tools are executing', t => {
+	// Test that we don't exit while tools are being executed
+	const appStateExecutingTools = {
+		isThinking: false,
+		isToolExecuting: true, // Tools are running
+		isBashExecuting: false,
+		isToolConfirmationMode: false,
+		isConversationComplete: false,
+		messages: [
+			{ role: 'user', content: 'test' },
+			{ role: 'assistant', content: 'response' },
+		],
+	};
+
+	const startTime = Date.now();
+	const maxExecutionTimeMs = 300000;
+
+	const { shouldExit } = isNonInteractiveModeComplete(
+		appStateExecutingTools,
+		startTime,
+		maxExecutionTimeMs,
+	);
+
+	t.false(shouldExit, 'Should NOT exit while tools are executing');
+});
+
+test('Non-interactive mode: does NOT exit when conversation is incomplete', t => {
+	// Test that we don't exit even if processing states are complete but conversation isn't done
+	const appStateIncompleteConversation = {
+		isThinking: false,
+		isToolExecuting: false,
+		isBashExecuting: false,
+		isToolConfirmationMode: false,
+		isConversationComplete: false, // Conversation not finished yet
+		messages: [
+			{ role: 'user', content: 'test' },
+			{ role: 'assistant', content: 'response' },
+		],
+	};
+
+	const startTime = Date.now();
+	const maxExecutionTimeMs = 300000;
+
+	const { shouldExit } = isNonInteractiveModeComplete(
+		appStateIncompleteConversation,
+		startTime,
+		maxExecutionTimeMs,
+	);
+
+	t.false(shouldExit, 'Should NOT exit when conversation is incomplete');
+	t.false(
+		appStateIncompleteConversation.isConversationComplete,
+		'Conversation is not complete',
+	);
+});
+
+// ============================================================================
+// CLI Integration Tests
+// ============================================================================
+
+test('Non-interactive mode: CLI parsing integration', t => {
+	// This test verifies integration with CLI argument parsing
+	// Based on cli.tsx, the nonInteractivePrompt is extracted from process.argv
+
+	// Test that the CLI correctly parses the 'run' command
+	const args = ['run', 'test', 'prompt'];
+	const runCommandIndex = args.findIndex(arg => arg === 'run');
+	const prompt =
+		runCommandIndex !== -1 && args[runCommandIndex + 1]
+			? args.slice(runCommandIndex + 1).join(' ')
+			: undefined;
+
+	t.is(prompt, 'test prompt');
+});
+
+test('Non-interactive mode: CLI parsing with complex prompt', t => {
+	// Test that the CLI correctly parses complex prompts
+	const args = [
+		'--some-flag',
+		'run',
+		'create',
+		'a',
+		'new',
+		'file',
+		'with',
+		'content',
+	];
+	const runCommandIndex = args.findIndex(arg => arg === 'run');
+	const prompt =
+		runCommandIndex !== -1 && args[runCommandIndex + 1]
+			? args.slice(runCommandIndex + 1).join(' ')
+			: undefined;
+
+	t.is(prompt, 'create a new file with content');
+});
+
+test('Non-interactive mode: exits with tool-approval reason when tool approval required', t => {
+	// Test that we exit with tool-approval reason when a message indicates tool approval is required
+	const appStateToolApprovalRequired = {
+		isThinking: false,
+		isToolExecuting: false,
+		isBashExecuting: false,
+		isToolConfirmationMode: false,
+		isConversationComplete: true,
+		messages: [
+			{ role: 'user', content: 'test' },
+			{ role: 'error', content: 'Tool approval required for: `execute_bash`' },
+		],
+	};
+
+	const startTime = Date.now();
+	const maxExecutionTimeMs = 300000;
+
+	const { shouldExit, reason } = isNonInteractiveModeComplete(
+		appStateToolApprovalRequired,
+		startTime,
+		maxExecutionTimeMs,
+	);
+
+	t.true(shouldExit, 'Should exit when tool approval is required');
+	t.is(reason, 'tool-approval', 'Exit reason should be tool-approval');
+});
+
+test('Non-interactive mode: CLI parsing without run command', t => {
+	// Test that the CLI correctly handles cases without run command
+	const args = ['--some-flag'];
+	const runCommandIndex = args.findIndex(arg => arg === 'run');
+	const prompt =
+		runCommandIndex !== -1 && args[runCommandIndex + 1]
+			? args.slice(runCommandIndex + 1).join(' ')
+			: undefined;
+
+	t.is(prompt, undefined);
+});

package/source/cli.spec.ts

@@ -0,0 +1,73 @@
+import test from 'ava';
+
+// Test CLI argument parsing for non-interactive mode
+// These tests verify that the CLI correctly parses the 'run' command
+
+// Helper function to parse prompt from args (mimics the logic in cli.tsx)
+function parsePrompt(args: string[]): string | undefined {
+	const runCommandIndex = args.findIndex(arg => arg === 'run');
+	if (runCommandIndex !== -1 && args[runCommandIndex + 1]) {
+		// Filter out known flags after 'run' when constructing the prompt
+		const promptArgs: string[] = [];
+		const knownFlags = new Set([]);
+		const afterRunArgs = args.slice(runCommandIndex + 1);
+		for (let i = 0; i < afterRunArgs.length; i++) {
+			const arg = afterRunArgs[i];
+			promptArgs.push(arg);
+		}
+		return promptArgs.join(' ');
+	}
+	return undefined;
+}
+
+test('CLI parsing: detects run command with single word prompt', t => {
+	const args = ['run', 'help'];
+	const prompt = parsePrompt(args);
+
+	t.is(prompt, 'help');
+});
+
+test('CLI parsing: detects run command with multi-word prompt', t => {
+	const args = ['run', 'tell', 'agent', 'what', 'to', 'do'];
+	const prompt = parsePrompt(args);
+
+	t.is(prompt, 'tell agent what to do');
+});
+
+test('CLI parsing: detects run command with quoted prompt', t => {
+	const args = ['run', 'tell agent what to do'];
+	const prompt = parsePrompt(args);
+
+	t.is(prompt, 'tell agent what to do');
+});
+
+test('CLI parsing: returns undefined when run command not present', t => {
+	const args = ['--some-flag', 'value'];
+	const prompt = parsePrompt(args);
+
+	t.is(prompt, undefined);
+});
+
+test('CLI parsing: returns undefined when run command has no prompt', t => {
+	const args = ['run'];
+	const prompt = parsePrompt(args);
+
+	t.is(prompt, undefined);
+});
+
+test('CLI parsing: handles mixed arguments with run command', t => {
+	const args = ['--some-flag', 'run', 'create', 'a', 'new', 'file'];
+	const prompt = parsePrompt(args);
+
+	t.is(prompt, 'create a new file');
+});
+
+test('CLI parsing: handles empty args array', t => {
+	const args: string[] = [];
+	const prompt = parsePrompt(args);
+
+	t.is(prompt, undefined);
+});
+
+// New tests for flag filtering
+

package/source/cli.tsx

@@ -0,0 +1,51 @@
+#!/usr/bin/env node
+import App from '@/app';
+import type { LoggingCliConfig } from '@/utils/logging/types';
+import { render } from 'ink';
+
+// Parse CLI arguments
+const args = process.argv.slice(2);
+
+
+// Parse logging control flags
+const logToFile = args.includes('--log-file');
+const logToConsole = args.includes('--log-console');
+const noLogFile = args.includes('--no-log-file');
+const noLogConsole = args.includes('--no-log-console');
+
+const loggingConfig: LoggingCliConfig = {
+	logToFile,
+	logToConsole,
+	noLogFile,
+	noLogConsole,
+};
+
+
+
+// Check for non-interactive mode (run command)
+let nonInteractivePrompt: string | undefined;
+const runCommandIndex = args.findIndex(arg => arg === 'run');
+const afterRunArgs =
+	runCommandIndex !== -1 ? args.slice(runCommandIndex + 1) : [];
+if (runCommandIndex !== -1 && args[runCommandIndex + 1]) {
+	// Filter out known flags after 'run' when constructing the prompt
+	const promptArgs: string[] = [];
+	const _knownFlags = new Set([]);
+	for (let i = 0; i < afterRunArgs.length; i++) {
+		const arg = afterRunArgs[i];
+
+		promptArgs.push(arg);
+	}
+	nonInteractivePrompt = promptArgs.join(' ');
+}
+
+const nonInteractiveMode = runCommandIndex !== -1;
+
+render(
+	<App
+
+		nonInteractivePrompt={nonInteractivePrompt}
+		nonInteractiveMode={nonInteractiveMode}
+		loggingConfig={loggingConfig}
+	/>,
+);

package/source/client-factory.spec.ts

@@ -0,0 +1,48 @@
+import { writeFileSync, rmSync, existsSync, mkdirSync } from 'fs';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import test from 'ava';
+import { createLLMClient, ConfigurationError } from './client-factory';
+import { reloadAppConfig } from '@/config/index';
+
+// Create a temporary test directory
+const testDir = join(tmpdir(), `coder-client-factory-test-${Date.now()}`);
+
+test.before(() => {
+	// Create test directory
+	mkdirSync(testDir, {recursive: true});
+});
+
+test.after.always(() => {
+	// Clean up test directory
+	if (existsSync(testDir)) {
+		rmSync(testDir, {recursive: true, force: true});
+	}
+});
+
+test('createLLMClient - ConfigurationError class works correctly', t => {
+	const error = new ConfigurationError('Test message', '/test/path', '/cwd/path', true);
+
+	t.is(error.name, 'ConfigurationError');
+	t.is(error.message, 'Test message');
+	t.is(error.configPath, '/test/path');
+	t.is(error.cwdPath, '/cwd/path');
+	t.true(error.isEmptyConfig);
+});
+
+test('createLLMClient - ConfigurationError can be caught by instance', t => {
+	const error = new ConfigurationError('Test message', '/test/path');
+
+	t.true(error instanceof Error);
+	t.true(error instanceof ConfigurationError);
+});
+
+test('createLLMClient - ConfigurationError with optional parameters', t => {
+	const error1 = new ConfigurationError('Test', '/test/path');
+	t.is(error1.cwdPath, undefined);
+	t.false(error1.isEmptyConfig);
+
+	const error2 = new ConfigurationError('Test', '/test/path', undefined, false);
+	t.is(error2.cwdPath, undefined);
+	t.false(error2.isEmptyConfig);
+});

package/source/client-factory.ts

@@ -0,0 +1,178 @@
+import { existsSync } from 'fs';
+import { join } from 'path';
+import { AISDKClient } from '@/ai-sdk-client';
+import { appConfig, getClosestConfigFile } from '@/config/index';
+import { loadPreferences } from '@/config/preferences';
+import { TIMEOUT_PROVIDER_CONNECTION_MS } from '@/constants';
+import type { AIProviderConfig, LLMClient } from '@/types/index';
+
+// Custom error class for configuration errors that need special UI handling
+export class ConfigurationError extends Error {
+	constructor(
+		message: string,
+		public configPath: string,
+		public cwdPath?: string,
+		public isEmptyConfig: boolean = false,
+	) {
+		super(message);
+		this.name = 'ConfigurationError';
+	}
+}
+
+export async function createLLMClient(
+	provider?: string,
+): Promise<{ client: LLMClient; actualProvider: string }> {
+	// Check if coder.config.json exists
+	const agentsJsonPath = getClosestConfigFile('coder.config.json');
+	const hasConfigFile = existsSync(agentsJsonPath);
+
+	// Use AI SDK - it handles both tool-calling and non-tool-calling models
+	return createAISDKClient(provider, hasConfigFile);
+}
+
+async function createAISDKClient(
+	requestedProvider?: string,
+	hasConfigFile = true,
+): Promise<{ client: LLMClient; actualProvider: string }> {
+	// Load provider configs
+	const providers = loadProviderConfigs();
+
+	if (providers.length === 0) {
+		const configPath = getClosestConfigFile('coder.config.json');
+		const cwd = process.cwd();
+		const isInCwd = configPath.startsWith(cwd);
+		const cwdPath = !isInCwd ? join(cwd, 'coder.config.json') : undefined;
+
+		if (!hasConfigFile) {
+			throw new ConfigurationError(
+				'No coder.config.json found',
+				configPath,
+				cwdPath,
+				false,
+			);
+		} else {
+			throw new ConfigurationError(
+				'No providers configured in coder.config.json',
+				configPath,
+				cwdPath,
+				true,
+			);
+		}
+	}
+
+	// Determine which provider to try first
+	let targetProvider: string;
+	if (requestedProvider) {
+		targetProvider = requestedProvider;
+	} else {
+		// Use preferences or default to first available provider
+		const preferences = loadPreferences();
+		targetProvider = preferences.lastProvider || providers[0].name;
+	}
+
+	// Order providers: requested first, then others
+	const availableProviders = providers.map(p => p.name);
+	const providerOrder = [
+		targetProvider,
+		...availableProviders.filter(p => p !== targetProvider),
+	];
+
+	const errors: string[] = [];
+
+	for (const providerType of providerOrder) {
+		try {
+			const providerConfig = providers.find(p => p.name === providerType);
+			if (!providerConfig) {
+				continue;
+			}
+
+			// Test provider connection
+			await testProviderConnection(providerConfig);
+
+			const client = await AISDKClient.create(providerConfig);
+
+			return { client, actualProvider: providerType };
+		} catch (error: unknown) {
+			const errorMessage =
+				error instanceof Error ? error.message : 'Unknown error';
+			errors.push(`${providerType}: ${errorMessage}`);
+		}
+	}
+
+	// If we get here, all providers failed
+	if (!hasConfigFile) {
+		const combinedError = `No providers available: ${errors[0]?.split(': ')[1] || 'Unknown error'
+			}\n\nPlease create an coder.config.json file with provider configuration.`;
+		throw new Error(combinedError);
+	} else {
+		const combinedError = `All configured providers failed:\n${errors
+			.map(e => `• ${e}`)
+			.join(
+				'\n',
+			)}\n\nPlease check your provider configuration in coder.config.json`;
+		throw new Error(combinedError);
+	}
+}
+
+function loadProviderConfigs(): AIProviderConfig[] {
+	const providers: AIProviderConfig[] = [];
+
+	// Load providers from the new providers array structure
+	if (appConfig.providers) {
+		for (const provider of appConfig.providers) {
+			providers.push({
+				name: provider.name,
+				type: 'openai',
+				models: provider.models || [],
+				requestTimeout: provider.requestTimeout,
+				socketTimeout: provider.socketTimeout,
+				connectionPool: provider.connectionPool,
+				config: {
+					baseURL: provider.baseUrl,
+					apiKey: provider.apiKey || 'dummy-key',
+				},
+			});
+		}
+	}
+
+	return providers;
+}
+
+async function testProviderConnection(
+	providerConfig: AIProviderConfig,
+): Promise<void> {
+	// Test local servers for connectivity
+	if (
+		providerConfig.config.baseURL &&
+		providerConfig.config.baseURL.includes('localhost')
+	) {
+		try {
+			await fetch(providerConfig.config.baseURL, {
+				signal: AbortSignal.timeout(TIMEOUT_PROVIDER_CONNECTION_MS),
+			});
+			// Don't check response.ok as some servers return 404 for root path
+			// We just need to confirm the server responded (not a network error)
+		} catch (error) {
+			// Only throw if it's a network error, not a 404 or other HTTP response
+			if (error instanceof TypeError) {
+				throw new Error(
+					`Server not accessible at ${providerConfig.config.baseURL}`,
+				);
+			}
+			// For AbortError (timeout), also throw
+			if (error instanceof Error && error.name === 'AbortError') {
+				throw new Error(
+					`Server not accessible at ${providerConfig.config.baseURL}`,
+				);
+			}
+			// Other errors (like HTTP errors) mean the server is responding, so pass
+		}
+	}
+	// Require API key for hosted providers
+	if (
+		!providerConfig.config.apiKey &&
+		!providerConfig.config.baseURL?.includes('localhost')
+	) {
+		throw new Error('API key required for hosted providers');
+	}
+}