@gguf/coder 0.3.0 → 0.3.1

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

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

@@ -0,0 +1,76 @@
+/**
+ * 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

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

@@ -0,0 +1,153 @@
+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;
+}