@gguf/coder 0.3.1 → 0.3.2

package/source/utils/indentation-normalizer.spec.ts

@@ -1,216 +0,0 @@
-import test from 'ava';
-import {normalizeIndentation} from './indentation-normalizer';
-
-test('normalizeIndentation - empty array returns empty array', t => {
-	const result = normalizeIndentation([]);
-	t.deepEqual(result, []);
-});
-
-test('normalizeIndentation - single line with no indentation', t => {
-	const result = normalizeIndentation(['const x = 1;']);
-	t.deepEqual(result, ['const x = 1;']);
-});
-
-test('normalizeIndentation - single line with indentation becomes unindented', t => {
-	const result = normalizeIndentation(['    const x = 1;']);
-	t.deepEqual(result, ['const x = 1;']);
-});
-
-test('normalizeIndentation - multiple lines with same indentation', t => {
-	const input = ['    const x = 1;', '    const y = 2;', '    const z = 3;'];
-	const expected = ['const x = 1;', 'const y = 2;', 'const z = 3;'];
-	t.deepEqual(normalizeIndentation(input), expected);
-});
-
-test('normalizeIndentation - preserves relative indentation with spaces', t => {
-	const input = [
-		'    function test() {',
-		'      return 1;',
-		'    }',
-	];
-	const expected = [
-		'function test() {',
-		'  return 1;',
-		'}',
-	];
-	t.deepEqual(normalizeIndentation(input), expected);
-});
-
-test('normalizeIndentation - preserves relative indentation with tabs', t => {
-	const input = [
-		'\t\tfunction test() {',
-		'\t\t\treturn 1;',
-		'\t\t}',
-	];
-	const expected = [
-		'function test() {',
-		'  return 1;', // Now uses 2 spaces instead of tab
-		'}',
-	];
-	t.deepEqual(normalizeIndentation(input), expected);
-});
-
-test('normalizeIndentation - handles mixed indentation (tabs and spaces)', t => {
-	const input = [
-		'\t\tfunction test() {',
-		'\t\t  return 1;', // 2 tabs + 2 spaces
-		'\t\t}',
-	];
-	// Min indent is 2 tabs = 2 normalized units
-	// Line 2 has 2 tabs + 2 spaces = 2 + 1 = 3 normalized units
-	// Relative indent: 0, 1, 0
-	// Always uses 2 spaces for display
-	const expected = [
-		'function test() {',
-		'  return 1;',
-		'}',
-	];
-	t.deepEqual(normalizeIndentation(input), expected);
-});
-
-test('normalizeIndentation - empty lines are preserved', t => {
-	const input = [
-		'    function test() {',
-		'',
-		'      return 1;',
-		'    }',
-	];
-	const expected = [
-		'function test() {',
-		'',
-		'  return 1;',
-		'}',
-	];
-	t.deepEqual(normalizeIndentation(input), expected);
-});
-
-test('normalizeIndentation - handles code with no minimum indentation', t => {
-	const input = [
-		'function test() {',
-		'  return 1;',
-		'}',
-	];
-	// Already at 0 indentation, should return as-is
-	t.deepEqual(normalizeIndentation(input), input);
-});
-
-test('normalizeIndentation - deeply nested code', t => {
-	const input = [
-		'          if (condition) {',
-		'            while (true) {',
-		'              doSomething();',
-		'            }',
-		'          }',
-	];
-	const expected = [
-		'if (condition) {',
-		'  while (true) {',
-		'    doSomething();',
-		'  }',
-		'}',
-	];
-	t.deepEqual(normalizeIndentation(input), expected);
-});
-
-test('normalizeIndentation - code with varying indentation levels', t => {
-	const input = [
-		'      const items = [',
-		'        {id: 1},',
-		'        {id: 2},',
-		'      ];',
-	];
-	const expected = [
-		'const items = [',
-		'  {id: 1},',
-		'  {id: 2},',
-		'];',
-	];
-	t.deepEqual(normalizeIndentation(input), expected);
-});
-
-test('normalizeIndentation - all empty lines returns input', t => {
-	const input = ['', '', ''];
-	t.deepEqual(normalizeIndentation(input), input);
-});
-
-test('normalizeIndentation - handles odd number of spaces', t => {
-	const input = [
-		'     const x = 1;', // 5 spaces = 2 normalized units
-		'       const y = 2;', // 7 spaces = 3 normalized units
-	];
-	// Min indent is 2 units
-	// Relative: 0, 1
-	const expected = [
-		'const x = 1;',
-		'  const y = 2;',
-	];
-	t.deepEqual(normalizeIndentation(input), expected);
-});
-
-test('normalizeIndentation - always uses 2 spaces for display', t => {
-	const input = [
-		'\t\tconst x = 1;',
-		'\t\t\tconst y = 2;',
-	];
-	const result = normalizeIndentation(input);
-	// Should use 2 spaces for relative indentation (not tabs)
-	t.deepEqual(result, [
-		'const x = 1;',
-		'  const y = 2;',
-	]);
-});
-
-test('normalizeIndentation - uses spaces when no tabs detected', t => {
-	const input = [
-		'    const x = 1;',
-		'      const y = 2;',
-	];
-	const result = normalizeIndentation(input);
-	// Should use 2 spaces for relative indentation
-	t.deepEqual(result, [
-		'const x = 1;',
-		'  const y = 2;',
-	]);
-});
-
-test('normalizeIndentation - JSX example with deep nesting', t => {
-	const input = [
-		'        return (',
-		'          <div>',
-		'            {items.map(item => (',
-		'              <button onClick={() => handleClick(item.id)}>',
-		'                {item.name}',
-		'              </button>',
-		'            ))}',
-		'          </div>',
-		'        );',
-	];
-	const expected = [
-		'return (',
-		'  <div>',
-		'    {items.map(item => (',
-		'      <button onClick={() => handleClick(item.id)}>',
-		'        {item.name}',
-		'      </button>',
-		'    ))}',
-		'  </div>',
-		');',
-	];
-	t.deepEqual(normalizeIndentation(input), expected);
-});
-
-test('normalizeIndentation - handles whitespace-only lines as empty', t => {
-	const input = [
-		'    function test() {',
-		'      ',
-		'      return 1;',
-		'    }',
-	];
-	const expected = [
-		'function test() {',
-		'      ', // Whitespace-only line preserved as-is
-		'  return 1;',
-		'}',
-	];
-	t.deepEqual(normalizeIndentation(input), expected);
-});

package/source/utils/indentation-normalizer.ts

@@ -1,76 +0,0 @@
-/**
- * Detects the minimum indentation level in a set of lines and returns
- * normalized lines with relative indentation.
- *
- * Example:
- *   Input:  ["      const x = 1;", "        const y = 2;"]
- *   Output: ["const x = 1;", "\tconst y = 2;"]
- */
-export function normalizeIndentation(lines: string[]): string[] {
-	if (lines.length === 0) {
-		return lines;
-	}
-
-	// Find minimum indentation level (excluding empty lines)
-	let minIndent = Number.POSITIVE_INFINITY;
-
-	for (const line of lines) {
-		if (line.trim().length === 0) {
-			continue; // Skip empty lines
-		}
-
-		// Count leading whitespace
-		const match = line.match(/^(\s+)/);
-		if (match) {
-			const whitespace = match[1];
-
-			// Convert to a normalized count (treating tab as 1 unit, 2 spaces as 1 unit)
-			const tabCount = (whitespace.match(/\t/g) || []).length;
-			const spaceCount = (whitespace.match(/ /g) || []).length;
-			const normalizedIndent = tabCount + Math.floor(spaceCount / 2);
-
-			minIndent = Math.min(minIndent, normalizedIndent);
-		} else {
-			// Line has no leading whitespace
-			minIndent = 0;
-			break;
-		}
-	}
-
-	// If all lines are empty, return as-is
-	if (minIndent === Number.POSITIVE_INFINITY) {
-		return lines;
-	}
-
-	// No normalization needed if already at 0 indentation
-	if (minIndent === 0) {
-		return lines;
-	}
-
-	// Always use 2 spaces for display (compact and terminal-friendly)
-	const indentChar = '  ';
-
-	// Normalize each line
-	return lines.map(line => {
-		if (line.trim().length === 0) {
-			return line; // Keep empty lines as-is
-		}
-
-		// Calculate current indentation level
-		const match = line.match(/^(\s+)/);
-		if (!match) {
-			return line; // No indentation to normalize
-		}
-
-		const whitespace = match[1];
-		const tabCount = (whitespace.match(/\t/g) || []).length;
-		const spaceCount = (whitespace.match(/ /g) || []).length;
-		const currentIndent = tabCount + Math.floor(spaceCount / 2);
-
-		// Calculate relative indentation
-		const relativeIndent = Math.max(0, currentIndent - minIndent);
-
-		// Return line with normalized indentation
-		return indentChar.repeat(relativeIndent) + line.trimStart();
-	});
-}

package/source/utils/installation-detector.spec.ts

@@ -1,178 +0,0 @@
-import test from 'ava';
-import {
-	detectFromPath,
-	detectInstallationMethod,
-} from './installation-detector';
-
-console.log(`\ninstallation-detector.spec.ts`);
-
-test.beforeEach(() => {
-	// Clean up environment variables before each test
-	delete process.env.CODER_INSTALL_METHOD;
-	delete process.env.npm_config_prefix;
-	delete process.env.npm_config_global;
-	delete process.env.PNPM_HOME;
-	delete process.env.npm_execpath;
-	delete process.env.HOMEBREW_PREFIX;
-	delete process.env.HOMEBREW_CELLAR;
-});
-
-// Environment override tests
-test('detectInstallationMethod: respects env override for npm', t => {
-	process.env.CODER_INSTALL_METHOD = 'npm';
-	t.is(detectInstallationMethod(), 'npm');
-});
-
-test('detectInstallationMethod: respects env override for homebrew', t => {
-	process.env.CODER_INSTALL_METHOD = 'homebrew';
-	t.is(detectInstallationMethod(), 'homebrew');
-});
-
-test('detectInstallationMethod: respects env override for nix', t => {
-	process.env.CODER_INSTALL_METHOD = 'nix';
-	t.is(detectInstallationMethod(), 'nix');
-});
-
-test('detectInstallationMethod: respects env override for unknown', t => {
-	process.env.CODER_INSTALL_METHOD = 'unknown';
-	t.is(detectInstallationMethod(), 'unknown');
-});
-
-// Homebrew environment variable detection
-test('detectInstallationMethod: detects homebrew via HOMEBREW_PREFIX', t => {
-	process.env.HOMEBREW_PREFIX = '/opt/homebrew';
-	t.is(detectInstallationMethod(), 'homebrew');
-});
-
-test('detectInstallationMethod: detects homebrew via HOMEBREW_CELLAR', t => {
-	process.env.HOMEBREW_CELLAR = '/opt/homebrew/Cellar';
-	t.is(detectInstallationMethod(), 'homebrew');
-});
-
-// NPM environment variable detection
-test('detectInstallationMethod: detects npm via npm_config_prefix', t => {
-	process.env.npm_config_prefix = '/usr/local';
-	t.is(detectInstallationMethod(), 'npm');
-});
-
-test('detectInstallationMethod: detects npm via npm_config_global', t => {
-	process.env.npm_config_global = 'true';
-	t.is(detectInstallationMethod(), 'npm');
-});
-
-test('detectInstallationMethod: detects npm via PNPM_HOME', t => {
-	process.env.PNPM_HOME = '/home/user/.local/share/pnpm';
-	t.is(detectInstallationMethod(), 'npm');
-});
-
-test('detectInstallationMethod: detects npm via npm_execpath', t => {
-	process.env.npm_execpath = '/usr/local/lib/node_modules/npm/bin/npm-cli.js';
-	t.is(detectInstallationMethod(), 'npm');
-});
-
-// Path Detection Tests
-// These tests verify the detectFromPath function correctly identifies installation methods from paths
-
-test('detectFromPath: detects nix from /nix/store path', t => {
-	const path =
-		'/nix/store/abc123-coder-1.0.0/lib/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'nix');
-});
-
-test('detectFromPath: detects homebrew from Cellar path (macOS Intel)', t => {
-	const path =
-		'/usr/local/Cellar/coder/1.0.0/libexec/lib/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'homebrew');
-});
-
-test('detectFromPath: detects homebrew from Cellar path (macOS ARM)', t => {
-	const path =
-		'/opt/homebrew/Cellar/coder/1.0.0/libexec/lib/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'homebrew');
-});
-
-test('detectFromPath: detects homebrew from generic homebrew path', t => {
-	const path = '/opt/homebrew/lib/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'homebrew');
-});
-
-test('detectFromPath: detects homebrew from Linux homebrew path', t => {
-	const path =
-		'/home/linuxbrew/.linuxbrew/Cellar/coder/1.0.0/lib/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'homebrew');
-});
-
-test('detectFromPath: detects npm from node_modules path (global)', t => {
-	const path = '/usr/local/lib/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'npm');
-});
-
-test('detectFromPath: detects npm from node_modules path (local)', t => {
-	const path = '/home/user/project/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'npm');
-});
-
-test('detectFromPath: detects npm from pnpm store path', t => {
-	const path =
-		'/home/user/.pnpm-store/.pnpm/@nanocollective+coder@1.0.0/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'npm');
-});
-
-test('detectFromPath: detects npm from .bin directory', t => {
-	const path = '/usr/local/lib/node_modules/.bin/coder';
-	t.is(detectFromPath(path), 'npm');
-});
-
-test('detectFromPath: returns null for unrecognized paths', t => {
-	const path = '/home/user/Downloads/coder/dist';
-	t.is(detectFromPath(path), null);
-});
-
-test('detectFromPath: detects npm from Windows AppData path', t => {
-	// Windows npm global installations typically go to AppData
-	const path =
-		'C:\\Users\\user\\AppData\\Roaming\\npm\\node_modules\\@nanocollective\\coder\\dist';
-	t.is(detectFromPath(path), 'npm');
-});
-
-test('detectFromPath: nix takes precedence over node_modules', t => {
-	// Edge case: nix store might contain "node_modules" in the path
-	const path =
-		'/nix/store/abc123-coder-1.0.0/lib/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'nix');
-});
-
-test('detectFromPath: homebrew takes precedence over node_modules', t => {
-	// Edge case: homebrew path contains node_modules
-	const path =
-		'/opt/homebrew/Cellar/coder/1.0.0/lib/node_modules/@nanocollective/coder/dist';
-	t.is(detectFromPath(path), 'homebrew');
-});
-
-// Edge case tests
-test('detectInstallationMethod: env vars take precedence over path', t => {
-	// Even if running from a homebrew path, HOMEBREW_PREFIX should be checked first
-	process.env.HOMEBREW_PREFIX = '/opt/homebrew';
-	t.is(detectInstallationMethod(), 'homebrew');
-});
-
-test('detectInstallationMethod: ignores invalid env override and continues detection', t => {
-	// Set an invalid value
-	process.env.CODER_INSTALL_METHOD = 'invalid-method';
-
-	// Should fall back to normal detection (ignoring invalid env var)
-	// and return a valid installation method
-	const result = detectInstallationMethod();
-
-	// Should still return a valid installation method after warning
-	// (will be detected from the actual running environment - npm in this case since we're in node_modules)
-	t.true(
-		['npm', 'homebrew', 'nix', 'unknown'].includes(result),
-		`Should return valid installation method when invalid env var is set, got: ${result}`,
-	);
-
-	// Note: A warning is logged when an invalid env var is provided (visible in test output)
-	// but we don't assert on logging behavior here due to the complexity of mocking
-	// the structured logging system in tests. The warning is verified manually by inspecting
-	// test output which shows: "Invalid CODER_INSTALL_METHOD: invalid-method"
-});

package/source/utils/installation-detector.ts

@@ -1,153 +0,0 @@
-import {existsSync} from 'fs';
-import {dirname, join, sep} from 'path';
-import {fileURLToPath} from 'url';
-import {logWarning} from './message-queue';
-
-export type InstallationMethod = 'npm' | 'homebrew' | 'nix' | 'unknown';
-
-// Define a safe process wrapper to avoid using `any` while keeping compatibility
-type MaybeProcess = {
-	env?: {[key: string]: string | undefined};
-	argv?: string[];
-};
-
-const safeProcess: MaybeProcess =
-	typeof process !== 'undefined' ? (process as unknown as MaybeProcess) : {};
-
-/**
- * Detects installation method from a given module path.
- * Exported for testing purposes.
- * @param modulePath The path to check
- * @returns The detected installation method or null if not detected from path
- */
-export function detectFromPath(modulePath: string): InstallationMethod | null {
-	// Strategy 1: Check for Nix installation (most specific)
-	// Nix store has `/nix/store/` path with store hashes - this is very reliable
-	if (modulePath.includes('/nix/store/')) {
-		return 'nix';
-	}
-
-	// Strategy 2: Check for Homebrew installation via path
-	// Homebrew puts packages under Cellar directory in standard locations
-	// Common paths: /opt/homebrew, /usr/local, /home/linuxbrew/.linuxbrew
-	if (
-		modulePath.includes(`${sep}Cellar${sep}`) ||
-		modulePath.includes(`${sep}homebrew${sep}`)
-	) {
-		return 'homebrew';
-	}
-
-	// Strategy 3: Check for npm/pnpm/yarn installation using multiple signals
-	if (isNpmBasedInstallation(modulePath)) {
-		return 'npm';
-	}
-
-	return null;
-}
-
-/**
- * Detects how Coder was installed by using multiple detection strategies.
- * Uses a combination of path inspection, environment variables, and file system markers.
- * An environment variable `CODER_INSTALL_METHOD` can be used to override detection for testing.
- * @returns {InstallationMethod} The detected installation method.
- */
-export function detectInstallationMethod(): InstallationMethod {
-	// Env var override has highest priority for testing / debugging
-	const envOverride = safeProcess.env?.CODER_INSTALL_METHOD;
-	if (envOverride) {
-		const validMethods: InstallationMethod[] = [
-			'npm',
-			'homebrew',
-			'nix',
-			'unknown',
-		];
-		if (validMethods.includes(envOverride as InstallationMethod)) {
-			return envOverride as InstallationMethod;
-		}
-		// Warn about invalid value but continue with normal detection
-		logWarning(
-			`Invalid CODER_INSTALL_METHOD: "${envOverride}". Valid values: ${validMethods.join(
-				', ',
-			)}`,
-		);
-	}
-
-	// Strategy 1: Check environment variables (most reliable after override)
-	if (safeProcess.env?.HOMEBREW_PREFIX || safeProcess.env?.HOMEBREW_CELLAR) {
-		return 'homebrew';
-	}
-
-	// Use the module path of this file (compiled output in `dist`) to determine how it was installed.
-	const modulePath = dirname(fileURLToPath(import.meta.url));
-
-	// Strategy 2: Check path-based detection
-	const pathResult = detectFromPath(modulePath);
-	if (pathResult) {
-		return pathResult;
-	}
-
-	return 'unknown';
-}
-
-/**
- * Checks if this is an npm-based installation (npm, pnpm, or yarn).
- * Uses multiple detection strategies for robustness across different package managers.
- */
-function isNpmBasedInstallation(modulePath: string): boolean {
-	// Check 1: Environment variables set by package managers
-	if (
-		safeProcess.env?.npm_config_prefix ||
-		safeProcess.env?.npm_config_global ||
-		safeProcess.env?.PNPM_HOME ||
-		safeProcess.env?.npm_execpath
-	) {
-		return true;
-	}
-
-	// Check 2: Standard node_modules path (npm, yarn v1)
-	if (modulePath.includes('node_modules')) {
-		return true;
-	}
-
-	// Check 3: pnpm store structure (.pnpm directory)
-	if (modulePath.includes(`.pnpm${sep}`)) {
-		return true;
-	}
-
-	// Check 4: Look for .bin directory in parent paths (all package managers use this)
-	// This handles symlinked executables
-	const binDirPattern = `${sep}.bin${sep}`;
-	if (modulePath.includes(binDirPattern)) {
-		return true;
-	}
-
-	// Check 5: Look for package.json in expected locations relative to the module
-	// For global installs, package.json should be in parent directories
-	// This handles edge cases like custom install locations
-	return hasPackageJsonMarker(modulePath);
-}
-
-/**
- * Walks up the directory tree looking for package.json as a marker of npm installation.
- * Only checks a few levels to avoid excessive file system operations.
- */
-function hasPackageJsonMarker(startPath: string): boolean {
-	let currentPath = startPath;
-	const maxLevelsToCheck = 4; // Limit to prevent excessive traversal
-
-	for (let i = 0; i < maxLevelsToCheck; i++) {
-		const packageJsonPath = join(currentPath, 'package.json'); // nosemgrep
-		if (existsSync(packageJsonPath)) {
-			return true;
-		}
-
-		const parentPath = dirname(currentPath);
-		// Stop if we've reached the root
-		if (parentPath === currentPath) {
-			break;
-		}
-		currentPath = parentPath;
-	}
-
-	return false;
-}