@gguf/coder 0.3.0 → 0.3.1

package/source/config/index.ts

@@ -0,0 +1,154 @@
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from 'fs';
+import { homedir } from 'os';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { substituteEnvVars } from '@/config/env-substitution';
+import { getConfigPath } from '@/config/paths';
+import { loadPreferences } from '@/config/preferences';
+import { defaultTheme, getThemeColors } from '@/config/themes';
+import type { AppConfig, Colors } from '@/types/index';
+import { logError, logWarning } from '@/utils/message-queue';
+import { config as loadEnv } from 'dotenv';
+
+// Load .env file from working directory (shell environment takes precedence)
+// Suppress dotenv console output by temporarily redirecting stdout
+const envPath = join(process.cwd(), '.env');
+if (existsSync(envPath)) {
+	const originalWrite = process.stdout.write.bind(process.stdout);
+	process.stdout.write = () => true;
+	try {
+		loadEnv({ path: envPath });
+	} finally {
+		process.stdout.write = originalWrite;
+	}
+}
+
+// Hold a map of what config files are where
+export const confDirMap: Record<string, string> = {};
+
+// Find the closest config file for the requested configuration file
+export function getClosestConfigFile(fileName: string): string {
+	try {
+		const configDir = getConfigPath();
+
+		// First, lets check for a working directory config
+		const cwdPath = join(process.cwd(), fileName); // nosemgrep
+		if (existsSync(cwdPath)) {
+			// nosemgrep
+			confDirMap[fileName] = cwdPath; // nosemgrep
+
+			return cwdPath; // nosemgrep
+		}
+
+		// Next lets check the $HOME for a hidden file. This should only be for
+		// legacy support
+		const homePath = join(homedir(), `.${fileName}`); // nosemgrep
+		if (existsSync(homePath)) {
+			// nosemgrep
+			confDirMap[fileName] = homePath; // nosemgrep
+
+			return homePath; // nosemgrep
+		}
+
+		// Last, lets look for an user level config.
+
+		// If the file doesn't exist, create it
+		const configPath = join(configDir, fileName); // nosemgrep
+		if (!existsSync(configPath)) {
+			// nosemgrep
+			createDefaultConfFile(configDir, fileName);
+		}
+
+		confDirMap[fileName] = configPath; // nosemgrep
+
+		return configPath; // nosemgrep
+	} catch (error) {
+		logError(`Failed to load ${fileName}: ${String(error)}`);
+	}
+
+	// The code should never hit this, but it makes the TS compiler happy.
+	return fileName;
+}
+
+function createDefaultConfFile(filePath: string, fileName: string): void {
+	try {
+		// If we cant find any, lets assume this is the first user run, create the
+		// correct file and direct the user to configure them correctly,
+		const configFilePath = join(filePath, fileName); // nosemgrep
+		if (!existsSync(configFilePath)) {
+			// nosemgrep
+			// Maybe add a better sample config?
+			const sampleConfig = {};
+
+			mkdirSync(filePath, { recursive: true });
+			writeFileSync(
+				configFilePath, // nosemgrep
+				JSON.stringify(sampleConfig, null, 2),
+				'utf-8',
+			);
+		}
+	} catch (error) {
+		logError(`Failed to write ${filePath}: ${String(error)}`);
+	}
+}
+
+// Function to load app configuration from coder.config.json if it exists
+function loadAppConfig(): AppConfig {
+	const agentsJsonPath = getClosestConfigFile('coder.config.json');
+
+	try {
+		const rawData = readFileSync(agentsJsonPath, 'utf-8');
+		const agentsData = JSON.parse(rawData) as { coder?: AppConfig };
+
+		// Apply environment variable substitution
+		const processedData = substituteEnvVars(agentsData);
+
+		if (processedData.coder) {
+			return {
+				providers: processedData.coder.providers ?? [],
+				mcpServers: processedData.coder.mcpServers ?? [],
+			};
+		}
+	} catch (error) {
+		logWarning(
+			`Failed to load coder.config.json: ${error instanceof Error ? error.message : String(error)}`,
+		);
+	}
+
+	return {};
+}
+
+export let appConfig = loadAppConfig();
+
+// Function to reload the app configuration (useful after config file changes)
+export function reloadAppConfig(): void {
+	appConfig = loadAppConfig();
+}
+
+let cachedColors: Colors | null = null;
+
+export function getColors(): Colors {
+	if (!cachedColors) {
+		const preferences = loadPreferences();
+		const selectedTheme = preferences.selectedTheme || defaultTheme;
+		cachedColors = getThemeColors(selectedTheme);
+	}
+	return cachedColors;
+}
+
+// Legacy export for backwards compatibility - use a getter to avoid circular dependency
+export const colors = new Proxy({} as Colors, {
+	get(_target, prop) {
+		return getColors()[prop as keyof Colors];
+	},
+});
+
+// Get the package root directory (where this module is installed)
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+// Go up from dist/config to package root, then to source/app/prompts/main-prompt.md
+// This works because source/app/prompts/main-prompt.md is included in the package.json files array
+export const promptPath = join(
+	__dirname,
+	'../../source/app/prompts/main-prompt.md',
+);

package/source/config/paths.spec.ts

@@ -0,0 +1,241 @@
+import * as path from 'path';
+import test from 'ava';
+import {getAppDataPath, getConfigPath} from './paths';
+
+// These tests intentionally lock in the public contract for Coder's
+// configuration and data directories. Do not change expected values
+// without providing a migration strategy.
+
+console.log(`\npaths.spec.ts`);
+
+const ORIGINAL_PLATFORM = process.platform;
+const ORIGINAL_ENV = {...process.env};
+
+function setPlatform(platform: NodeJS.Platform) {
+	Object.defineProperty(process, 'platform', {
+		value: platform,
+		configurable: true,
+	});
+}
+
+function resetEnvironment() {
+	for (const key of Object.keys(process.env)) {
+		if (!(key in ORIGINAL_ENV)) delete process.env[key];
+	}
+	for (const [key, value] of Object.entries(ORIGINAL_ENV)) {
+		process.env[key] = value as string;
+	}
+	Object.defineProperty(process, 'platform', {
+		value: ORIGINAL_PLATFORM,
+		configurable: true,
+	});
+}
+
+test.afterEach(() => {
+	resetEnvironment();
+});
+
+function testPathGetter(
+	t: import('ava').ExecutionContext,
+	platform: NodeJS.Platform,
+	env: Record<string, string | undefined>,
+	getter: () => string,
+	expected: string,
+) {
+	resetEnvironment();
+	setPlatform(platform);
+	for (const [key, value] of Object.entries(env)) {
+		if (value === undefined) delete process.env[key];
+		else process.env[key] = value;
+	}
+	t.is(getter(), expected);
+}
+
+// getAppDataPath
+
+test.serial('getAppDataPath uses CODER_DATA_DIR override verbatim', t => {
+	testPathGetter(
+		t,
+		'linux',
+		{
+			CODER_DATA_DIR: '/custom/data',
+			APPDATA: 'C:/Ignored',
+			XDG_DATA_HOME: '/ignored',
+		},
+		getAppDataPath,
+		'/custom/data',
+	);
+});
+
+test.serial('getAppDataPath darwin default path is stable', t => {
+	testPathGetter(
+		t,
+		'darwin',
+		{HOME: '/Users/test'},
+		getAppDataPath,
+		path.join('/Users/test', 'Library', 'Application Support', 'coder'),
+	);
+});
+
+test.serial('getAppDataPath win32 uses APPDATA when set', t => {
+	testPathGetter(
+		t,
+		'win32',
+		{APPDATA: path.join('C:', 'Users', 'test', 'AppData', 'Roaming')},
+		getAppDataPath,
+		path.join('C:', 'Users', 'test', 'AppData', 'Roaming', 'coder'),
+	);
+});
+
+test.serial(
+	'getAppDataPath win32 falls back to homedir Roaming when APPDATA missing',
+	t => {
+		testPathGetter(
+			t,
+			'win32',
+			{APPDATA: undefined, HOME: path.join('C:', 'Users', 'test')},
+			getAppDataPath,
+			path.join('C:', 'Users', 'test', 'AppData', 'Roaming', 'coder'),
+		);
+	},
+);
+
+test.serial(
+	'getAppDataPath linux honours XDG_DATA_HOME and ignores APPDATA',
+	t => {
+		testPathGetter(
+			t,
+			'linux',
+			{XDG_DATA_HOME: '/xdg-data', APPDATA: '/should-not-be-used'},
+			getAppDataPath,
+			path.join('/xdg-data', 'coder'),
+		);
+	},
+);
+
+test.serial('getAppDataPath linux falls back to ~/.local/share', t => {
+	testPathGetter(
+		t,
+		'linux',
+		{XDG_DATA_HOME: undefined, HOME: '/home/test'},
+		getAppDataPath,
+		path.join('/home/test', '.local', 'share', 'coder'),
+	);
+});
+
+test.serial(
+	'getAppDataPath non-standard platform falls back to Linux-style defaults',
+	t => {
+		testPathGetter(
+			t,
+			'freebsd',
+			{XDG_DATA_HOME: undefined, HOME: '/home/test'},
+			getAppDataPath,
+			path.join('/home/test', '.local', 'share', 'coder'),
+		);
+	},
+);
+
+// getConfigPath
+
+test.serial('getConfigPath uses CODER_CONFIG_DIR override verbatim', t => {
+	testPathGetter(
+		t,
+		'linux',
+		{
+			CODER_CONFIG_DIR: '/custom/config',
+			XDG_CONFIG_HOME: '/ignored',
+			APPDATA: 'C:/Ignored',
+		},
+		getConfigPath,
+		'/custom/config',
+	);
+});
+
+test.serial('getConfigPath darwin default path is stable', t => {
+	testPathGetter(
+		t,
+		'darwin',
+		{CODER_CONFIG_DIR: undefined, HOME: '/Users/test'},
+		getConfigPath,
+		path.join('/Users/test', 'Library', 'Preferences', 'coder'),
+	);
+});
+
+test.serial('getConfigPath win32 uses APPDATA when set', t => {
+	testPathGetter(
+		t,
+		'win32',
+		{
+			CODER_CONFIG_DIR: undefined,
+			APPDATA: path.join('C:', 'Users', 'test', 'AppData', 'Roaming'),
+		},
+		getConfigPath,
+		path.join('C:', 'Users', 'test', 'AppData', 'Roaming', 'coder'),
+	);
+});
+
+test.serial(
+	'getConfigPath win32 falls back to homedir Roaming when APPDATA missing',
+	t => {
+		testPathGetter(
+			t,
+			'win32',
+			{
+				CODER_CONFIG_DIR: undefined,
+				APPDATA: undefined,
+				HOME: path.join('C:', 'Users', 'test'),
+			},
+			getConfigPath,
+			path.join('C:', 'Users', 'test', 'AppData', 'Roaming', 'coder'),
+		);
+	},
+);
+
+test.serial(
+	'getConfigPath linux honours XDG_CONFIG_HOME and ignores APPDATA',
+	t => {
+		testPathGetter(
+			t,
+			'linux',
+			{
+				CODER_CONFIG_DIR: undefined,
+				XDG_CONFIG_HOME: '/xdg-config',
+				APPDATA: '/should-not-be-used',
+			},
+			getConfigPath,
+			path.join('/xdg-config', 'coder'),
+		);
+	},
+);
+
+test.serial('getConfigPath linux falls back to ~/.config', t => {
+	testPathGetter(
+		t,
+		'linux',
+		{
+			CODER_CONFIG_DIR: undefined,
+			XDG_CONFIG_HOME: undefined,
+			HOME: '/home/test',
+		},
+		getConfigPath,
+		path.join('/home/test', '.config', 'coder'),
+	);
+});
+
+test.serial(
+	'getConfigPath non-standard platform falls back to Linux-style defaults',
+	t => {
+		testPathGetter(
+			t,
+			'freebsd',
+			{
+				CODER_CONFIG_DIR: undefined,
+				XDG_CONFIG_HOME: undefined,
+				HOME: '/home/test',
+			},
+			getConfigPath,
+			path.join('/home/test', '.config', 'coder'),
+		);
+	},
+);

package/source/config/paths.ts

@@ -0,0 +1,55 @@
+import {homedir} from 'os';
+import {join} from 'path';
+
+export function getAppDataPath(): string {
+	// Allow explicit override via environment variable
+	if (process.env.CODER_DATA_DIR) {
+		return process.env.CODER_DATA_DIR;
+	}
+
+	// Check XDG_DATA_HOME first (works cross-platform for testing)
+	if (process.env.XDG_DATA_HOME) {
+		return join(process.env.XDG_DATA_HOME, 'coder');
+	}
+
+	// Platform-specific app data directories
+	let baseAppDataPath: string;
+	switch (process.platform) {
+		case 'win32': {
+			baseAppDataPath =
+				process.env.APPDATA ?? join(homedir(), 'AppData', 'Roaming');
+			break;
+		}
+		case 'darwin': {
+			baseAppDataPath = join(homedir(), 'Library', 'Application Support');
+			break;
+		}
+		default: {
+			baseAppDataPath = join(homedir(), '.local', 'share');
+		}
+	}
+	return join(baseAppDataPath, 'coder');
+}
+
+export function getConfigPath(): string {
+	// Allow explicit override via environment variable
+	if (process.env.CODER_CONFIG_DIR) {
+		return process.env.CODER_CONFIG_DIR;
+	}
+
+	// Platform-specific defaults
+	let baseConfigPath: string;
+	switch (process.platform) {
+		case 'win32':
+			baseConfigPath =
+				process.env.APPDATA ?? join(homedir(), 'AppData', 'Roaming');
+			break;
+		case 'darwin':
+			baseConfigPath = join(homedir(), 'Library', 'Preferences');
+			break;
+		default:
+			baseConfigPath =
+				process.env.XDG_CONFIG_HOME ?? join(homedir(), '.config');
+	}
+	return join(baseConfigPath, 'coder');
+}

package/source/config/preferences.ts

@@ -0,0 +1,51 @@
+import {readFileSync, writeFileSync} from 'fs';
+import {getClosestConfigFile} from '@/config/index';
+import {logError} from '@/utils/message-queue';
+
+import type {UserPreferences} from '@/types/index';
+
+let PREFERENCES_PATH: string | null = null;
+
+function getPreferencesPath(): string {
+	if (!PREFERENCES_PATH) {
+		PREFERENCES_PATH = getClosestConfigFile('coder-preferences.json');
+	}
+	return PREFERENCES_PATH;
+}
+
+export function loadPreferences(): UserPreferences {
+	try {
+		const data = readFileSync(getPreferencesPath(), 'utf-8');
+		return JSON.parse(data) as UserPreferences;
+	} catch (error) {
+		logError(`Failed to load preferences: ${String(error)}`);
+	}
+	return {};
+}
+
+export function savePreferences(preferences: UserPreferences): void {
+	try {
+		writeFileSync(getPreferencesPath(), JSON.stringify(preferences, null, 2));
+	} catch (error) {
+		logError(`Failed to save preferences: ${String(error)}`);
+	}
+}
+
+export function updateLastUsed(provider: string, model: string): void {
+	const preferences = loadPreferences();
+	preferences.lastProvider = provider;
+	preferences.lastModel = model;
+
+	// Also save the model for this specific provider
+	if (!preferences.providerModels) {
+		preferences.providerModels = {};
+	}
+	preferences.providerModels[provider] = model;
+
+	savePreferences(preferences);
+}
+
+export function getLastUsedModel(provider: string): string | undefined {
+	const preferences = loadPreferences();
+	return preferences.providerModels?.[provider];
+}