@gguf/coder 0.3.1 → 0.3.2

package/source/app.spec.tsx

@@ -1,244 +0,0 @@
-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

@@ -1,73 +0,0 @@
-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

@@ -1,51 +0,0 @@
-#!/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

@@ -1,48 +0,0 @@
-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

@@ -1,178 +0,0 @@
-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');
-	}
-}