@gguf/coder 0.3.0 → 0.3.1

package/source/utils/update-checker.spec.ts

@@ -0,0 +1,383 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import test from 'ava';
+import { checkForUpdates } from './update-checker';
+
+console.log(`\nupdate-checker.spec.ts`);
+
+// Get current version from package.json dynamically
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+const packageJsonPath = join(__dirname, '../../package.json');
+const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
+const CURRENT_VERSION = packageJson.version as string;
+
+// Mock fetch globally for testing
+const originalFetch = globalThis.fetch;
+
+// Helper to create mock fetch responses
+function createMockFetch(
+	status: number,
+	data: unknown,
+	shouldReject = false,
+): typeof fetch {
+	return (async () => {
+		if (shouldReject) {
+			throw new Error('Network error');
+		}
+
+		return {
+			ok: status >= 200 && status < 300,
+			status,
+			statusText: status === 200 ? 'OK' : 'Error',
+			json: async () => data,
+		} as Response;
+	}) as typeof fetch;
+}
+
+test.beforeEach(() => {
+	// Reset fetch before each test
+	globalThis.fetch = originalFetch;
+	// Default to npm install override
+	process.env.CODER_INSTALL_METHOD = 'npm';
+});
+
+test.afterEach(() => {
+	// Restore original fetch and env after each test
+	globalThis.fetch = originalFetch;
+	delete process.env.CODER_INSTALL_METHOD;
+});
+
+// Version Comparison Tests
+
+test('checkForUpdates: detects newer major version', async t => {
+	// Calculate a newer major version dynamically
+	const currentParts = CURRENT_VERSION.split('.');
+	const newerMajorVersion = `${parseInt(currentParts[0]) + 1}.0.0`;
+
+	globalThis.fetch = createMockFetch(200, {
+		version: newerMajorVersion,
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.true(result.hasUpdate);
+	t.is(result.currentVersion, CURRENT_VERSION);
+	t.is(result.latestVersion, newerMajorVersion);
+	t.truthy(result.updateCommand);
+});
+
+test('checkForUpdates: detects newer minor version', async t => {
+	// Calculate a newer minor version dynamically
+	const currentParts = CURRENT_VERSION.split('.');
+	const newerMinorVersion = `${currentParts[0]}.${parseInt(currentParts[1]) + 1
+		}.0`;
+
+	globalThis.fetch = createMockFetch(200, {
+		version: newerMinorVersion,
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.true(result.hasUpdate);
+	t.is(result.latestVersion, newerMinorVersion);
+});
+
+test('checkForUpdates: detects newer patch version', async t => {
+	// Calculate a newer patch version dynamically
+	const currentParts = CURRENT_VERSION.split('.');
+	const newerPatchVersion = `${currentParts[0]}.${currentParts[1]}.${parseInt(currentParts[2]) + 1
+		}`;
+
+	globalThis.fetch = createMockFetch(200, {
+		version: newerPatchVersion,
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.true(result.hasUpdate);
+	t.is(result.latestVersion, newerPatchVersion);
+});
+
+test('checkForUpdates: detects same version (no update)', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: CURRENT_VERSION,
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+	t.is(result.currentVersion, CURRENT_VERSION);
+	t.is(result.latestVersion, CURRENT_VERSION);
+	t.is(result.updateCommand, undefined);
+});
+
+test('checkForUpdates: detects older version (no update)', async t => {
+	// Calculate an older patch version dynamically
+	const currentParts = CURRENT_VERSION.split('.');
+	const patchNum = parseInt(currentParts[2]);
+	// Use 0 if current patch is already 0, otherwise decrement
+	const olderPatchVersion = `${currentParts[0]}.${currentParts[1]}.${Math.max(
+		0,
+		patchNum - 1,
+	)}`;
+
+	globalThis.fetch = createMockFetch(200, {
+		version: olderPatchVersion,
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+	t.is(result.latestVersion, olderPatchVersion);
+});
+
+test('checkForUpdates: handles version with v prefix', async t => {
+	// Use a newer major version with v prefix
+	const currentParts = CURRENT_VERSION.split('.');
+	const newerMajorVersion = `v${parseInt(currentParts[0]) + 1}.0.0`;
+
+	globalThis.fetch = createMockFetch(200, {
+		version: newerMajorVersion,
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.true(result.hasUpdate);
+	t.is(result.latestVersion, newerMajorVersion);
+});
+
+test('checkForUpdates: handles pre-release versions', async t => {
+	// Use a newer major version with pre-release tag
+	const currentParts = CURRENT_VERSION.split('.');
+	const newerPreReleaseVersion = `${parseInt(currentParts[0]) + 1}.0.0-beta.1`;
+
+	globalThis.fetch = createMockFetch(200, {
+		version: newerPreReleaseVersion,
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	// Pre-release info is stripped during comparison
+	t.true(result.hasUpdate);
+	t.is(result.latestVersion, newerPreReleaseVersion);
+});
+
+// Network Error Handling Tests
+
+test('checkForUpdates: handles network errors gracefully', async t => {
+	globalThis.fetch = createMockFetch(200, {}, true);
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+	t.truthy(result.currentVersion);
+	t.is(result.latestVersion, undefined);
+});
+
+test('checkForUpdates: handles HTTP 404 error', async t => {
+	globalThis.fetch = createMockFetch(404, {
+		error: 'Not found',
+	});
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+	t.truthy(result.currentVersion);
+});
+
+test('checkForUpdates: handles HTTP 500 error', async t => {
+	globalThis.fetch = createMockFetch(500, {
+		error: 'Internal server error',
+	});
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+	t.truthy(result.currentVersion);
+});
+
+test('checkForUpdates: handles timeout (via AbortSignal)', async t => {
+	// Simulate timeout by throwing AbortError
+	globalThis.fetch = (async () => {
+		const error = new Error('The operation was aborted');
+		error.name = 'AbortError';
+		throw error;
+	}) as typeof fetch;
+
+	const result = await checkForUpdates();
+
+	// Should handle timeout gracefully
+	t.false(result.hasUpdate);
+});
+
+// Response Format Tests
+
+test('checkForUpdates: returns correct update command', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: '2.0.0',
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.is(result.updateCommand, 'npm update -g @gguf/coder');
+});
+
+test('checkForUpdates: returns correct Homebrew command when installed via Homebrew', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: '2.0.0',
+		name: '@gguf/coder',
+	});
+
+	process.env.CODER_INSTALL_METHOD = 'homebrew';
+
+	const result = await checkForUpdates();
+
+	t.is(
+		result.updateCommand,
+		'brew list coder >/dev/null 2>&1 && brew upgrade coder || (echo "Error: coder not found in Homebrew. Please install it first with: brew install coder" && exit 1)',
+	);
+});
+
+test('checkForUpdates: returns message for Nix installations (no executable command)', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: '2.0.0',
+		name: '@gguf/coder',
+	});
+
+	process.env.CODER_INSTALL_METHOD = 'nix';
+
+	const result = await checkForUpdates();
+
+	t.is(
+		result.updateMessage,
+		'To update, re-run: nix run github:gguf/coder (or update your flake).',
+	);
+});
+
+test('checkForUpdates: includes current version in response', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: '2.0.0',
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.truthy(result.currentVersion);
+	t.regex(result.currentVersion, /^\d+\.\d+\.\d+/);
+});
+
+test('checkForUpdates: handles missing version field in response', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		name: '@gguf/coder',
+		// version field missing
+	});
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+});
+
+test('checkForUpdates: handles malformed JSON response', async t => {
+	globalThis.fetch = (async () => {
+		return {
+			ok: true,
+			status: 200,
+			statusText: 'OK',
+			json: async () => {
+				throw new Error('Invalid JSON');
+			},
+		} as unknown as Response;
+	}) as typeof fetch;
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+});
+
+// Edge Cases
+
+test('checkForUpdates: handles empty version string', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: '',
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+});
+
+test('checkForUpdates: handles version with extra segments', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: '2.0.0.1',
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	// Should compare first 3 segments
+	t.true(result.hasUpdate);
+});
+
+test('checkForUpdates: handles invalid version format', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: 'not-a-version',
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	// Should handle gracefully
+	t.false(result.hasUpdate);
+});
+
+// Integration Tests
+
+test('checkForUpdates: complete workflow for update available', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: '99.99.99',
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.true(result.hasUpdate);
+	t.truthy(result.currentVersion);
+	t.is(result.latestVersion, '99.99.99');
+	t.is(result.updateCommand, 'npm update -g @gguf/coder');
+});
+
+test('checkForUpdates: complete workflow for no update', async t => {
+	globalThis.fetch = createMockFetch(200, {
+		version: '0.0.1',
+		name: '@gguf/coder',
+	});
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+	t.truthy(result.currentVersion);
+	t.is(result.latestVersion, '0.0.1');
+	t.is(result.updateCommand, undefined);
+});
+
+test('checkForUpdates: complete workflow for network failure', async t => {
+	globalThis.fetch = createMockFetch(200, {}, true);
+
+	const result = await checkForUpdates();
+
+	t.false(result.hasUpdate);
+	t.truthy(result.currentVersion);
+	t.is(result.latestVersion, undefined);
+	t.is(result.updateCommand, undefined);
+});

package/source/utils/update-checker.ts

@@ -0,0 +1,183 @@
+import { readFileSync } from 'fs';
+import { dirname, join } from 'path';
+import { fileURLToPath } from 'url';
+import { loadPreferences, savePreferences } from '@/config/preferences';
+import { TIMEOUT_UPDATE_CHECK_MS } from '@/constants';
+import type { NpmRegistryResponse, UpdateInfo } from '@/types/index';
+import { logError } from '@/utils/message-queue';
+import { detectInstallationMethod } from './installation-detector';
+
+const UPDATE_COMMANDS = {
+	NPM: 'npm update -g @gguf/coder',
+	// Check if package exists before upgrading to provide better error messages
+	HOMEBREW:
+		'brew list coder >/dev/null 2>&1 && brew upgrade coder || (echo "Error: coder not found in Homebrew. Please install it first with: brew install coder" && exit 1)',
+} as const;
+
+const UPDATE_MESSAGES = {
+	NIX: 'To update, re-run: nix run github:gguf/coder (or update your flake).',
+	UNKNOWN:
+		'A new version is available. Please update using your package manager.',
+} as const;
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Compare two semver version strings
+ * Returns true if latest is greater than current
+ */
+function isNewerVersion(current: string, latest: string): boolean {
+	const parseVersion = (version: string) => {
+		const clean = version.replace(/^v/, '').split('-')[0]; // Remove 'v' prefix and pre-release info
+		return clean.split('.').map(num => parseInt(num) || 0);
+	};
+
+	const currentParts = parseVersion(current);
+	const latestParts = parseVersion(latest);
+
+	const maxLength = Math.max(currentParts.length, latestParts.length);
+
+	for (let i = 0; i < maxLength; i++) {
+		const currentPart = currentParts[i] || 0;
+		const latestPart = latestParts[i] || 0;
+
+		if (latestPart > currentPart) {
+			return true;
+		} else if (latestPart < currentPart) {
+			return false;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Get the current package version from package.json
+ */
+interface PackageJson {
+	version: string;
+	[key: string]: unknown;
+}
+
+function getCurrentVersion(): string {
+	try {
+		const packageJsonPath = join(__dirname, '../../package.json');
+		const packageJson = JSON.parse(
+			readFileSync(packageJsonPath, 'utf-8'),
+		) as PackageJson;
+		return packageJson.version;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logError(`Failed to read current version: ${errorMessage}`);
+		return '0.0.0';
+	}
+}
+
+/**
+ * Fetch the latest version from npm registry
+ */
+async function fetchLatestVersion(): Promise<string | null> {
+	try {
+		const response = await fetch(
+			'https://registry.npmjs.org/@gguf/coder/latest',
+			{
+				method: 'GET',
+				headers: {
+					Accept: 'application/json',
+					'User-Agent': 'coder-update-checker',
+				},
+				// Add timeout
+				signal: AbortSignal.timeout(TIMEOUT_UPDATE_CHECK_MS),
+			},
+		);
+
+		if (!response.ok) {
+			throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+		}
+
+		const data = (await response.json()) as NpmRegistryResponse;
+		return data.version;
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logError(`Failed to fetch latest version: ${errorMessage}`);
+		return null;
+	}
+}
+
+/**
+ * Update the last update check timestamp in preferences
+ */
+function updateLastCheckTime(): void {
+	const preferences = loadPreferences();
+	preferences.lastUpdateCheck = Date.now();
+	savePreferences(preferences);
+}
+
+/**
+ * Check for package updates
+ */
+export async function checkForUpdates(): Promise<UpdateInfo> {
+	const currentVersion = getCurrentVersion();
+
+	try {
+		const latestVersion = await fetchLatestVersion();
+		updateLastCheckTime();
+
+		if (!latestVersion) {
+			return {
+				hasUpdate: false,
+				currentVersion,
+			};
+		}
+
+		const hasUpdate = isNewerVersion(currentVersion, latestVersion);
+
+		function getUpdateDetails(hasUpdate: boolean): {
+			command?: string;
+			message?: string;
+		} {
+			if (!hasUpdate) {
+				return {};
+			}
+
+			const method = detectInstallationMethod();
+
+			// Use constants defined at top of file for maintainability
+
+			switch (method) {
+				case 'npm':
+					return { command: UPDATE_COMMANDS.NPM };
+				case 'homebrew':
+					return { command: UPDATE_COMMANDS.HOMEBREW };
+				case 'nix':
+					return { message: UPDATE_MESSAGES.NIX };
+				default:
+					// For 'unknown' fallback to a general message (do not attempt to run a command)
+					return { message: UPDATE_MESSAGES.UNKNOWN };
+			}
+		}
+
+		const updateDetails = getUpdateDetails(hasUpdate);
+
+		return {
+			hasUpdate,
+			currentVersion,
+			latestVersion,
+			updateCommand: updateDetails.command,
+			updateMessage: updateDetails.message,
+		};
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		logError(`Update check failed: ${errorMessage}`);
+
+		// Still update the timestamp to prevent hammering the API on repeated failures
+		updateLastCheckTime();
+
+		return {
+			hasUpdate: false,
+			currentVersion,
+			error: errorMessage,
+		};
+	}
+}

package/source/wizard/config-wizard.spec.tsx

@@ -0,0 +1,103 @@
+import test from 'ava';
+import {render} from 'ink-testing-library';
+import React from 'react';
+import {ConfigWizard} from './config-wizard.js';
+
+// ============================================================================
+// Tests for ConfigWizard Component Rendering
+// ============================================================================
+
+console.log(`\nconfig-wizard.spec.tsx – ${React.version}`);
+
+test('ConfigWizard renders with title', t => {
+	const {lastFrame} = render(
+		<ConfigWizard projectDir="/tmp/test-project" onComplete={() => {}} />,
+	);
+
+	const output = lastFrame();
+	t.truthy(output);
+	t.regex(output!, /Configuration Wizard/);
+});
+
+test('ConfigWizard shows initial location step', t => {
+	const {lastFrame} = render(
+		<ConfigWizard projectDir="/tmp/test-project" onComplete={() => {}} />,
+	);
+
+	const output = lastFrame();
+	t.regex(output!, /Where would you like to create your configuration/);
+});
+
+test('ConfigWizard shows keyboard shortcuts', t => {
+	const {lastFrame} = render(
+		<ConfigWizard projectDir="/tmp/test-project" onComplete={() => {}} />,
+	);
+
+	const output = lastFrame();
+	t.regex(output!, /Esc.*Exit wizard/);
+	t.regex(output!, /Shift\+Tab.*Go back/);
+});
+
+test('ConfigWizard shows location options', t => {
+	const {lastFrame} = render(
+		<ConfigWizard projectDir="/tmp/test-project" onComplete={() => {}} />,
+	);
+
+	const output = lastFrame();
+	t.regex(output!, /Current project directory/);
+	t.regex(output!, /Global user config/);
+});
+
+test('ConfigWizard renders without crashing when onCancel is provided', t => {
+	let cancelCalled = false;
+
+	const {lastFrame} = render(
+		<ConfigWizard
+			projectDir="/tmp/test-project"
+			onComplete={() => {}}
+			onCancel={() => {
+				cancelCalled = true;
+			}}
+		/>,
+	);
+
+	t.truthy(lastFrame());
+	t.false(cancelCalled); // Should not be called on render
+});
+
+test('ConfigWizard accepts projectDir prop', t => {
+	const projectDir = '/custom/project/path';
+
+	const {lastFrame} = render(
+		<ConfigWizard projectDir={projectDir} onComplete={() => {}} />,
+	);
+
+	// Component should render without errors
+	t.truthy(lastFrame());
+});
+
+test('ConfigWizard renders TitledBox with correct border', t => {
+	const {lastFrame} = render(
+		<ConfigWizard projectDir="/tmp/test-project" onComplete={() => {}} />,
+	);
+
+	const output = lastFrame();
+	// Check for rounded border characters
+	t.regex(output!, /╭/); // Top-left corner
+	t.regex(output!, /╮/); // Top-right corner
+	t.regex(output!, /╰/); // Bottom-left corner
+	t.regex(output!, /╯/); // Bottom-right corner
+});
+
+test('ConfigWizard renders with correct initial state', t => {
+	const {frames} = render(
+		<ConfigWizard projectDir="/tmp/test-project" onComplete={() => {}} />,
+	);
+
+	// Should have rendered at least one frame
+	t.true(frames.length > 0);
+
+	// First frame should show location step
+	const firstFrame = frames[0];
+	t.regex(firstFrame, /Configuration Wizard/);
+});