fix: support new Zig-based binary jac install (replaces pip install) (#95)

* fix: support binary jac install model (Zig-based, no pip venv)

- envVersion: fast version detection via ~/.cache/jac/rt dist-info scan
- envDetection: detect ~/.local/bin/jac and /usr/local/bin/jac directly
- envDetection: check .jac/venv (plugin venv) before old-style .venv
- manager: getPythonPath returns bare python for binary install paths
- manager: hide meaningless env name (.local) for global binary installs

* fix: refine binary install detection logic in environment manager and update default binary locator

* fix: simplify workspace venv detection by removing old binary model fallback

* fix: improve comments for clarity in environment detection and version retrieval

* Broaden single-binary python resolution and discovery across platforms

getPythonPath: check the sibling python exists on disk instead of matching
the .local/bin substring, so brew (/opt/homebrew/bin), /usr/local/bin, and
custom single-binary installs also resolve correctly (not just ~/.local/bin).

findDefaultBinary: also locate the binary at /opt/homebrew/bin, /usr/local/bin,
and the Windows %LOCALAPPDATA%\Programs\jac and %LOCALAPPDATA%\jac\bin
locations, independent of PATH.

Update getPythonPath tests to cover both the sibling-present (venv/conda) and
sibling-absent (single binary) branches.

---------

Co-authored-by: kugesan1105 <kugesan.sivasothynathan@jaseci.org>

Author: ThiruvarankanM

src/__tests__/env_test.test.ts

@@ -1,11 +1,18 @@
 import { EnvManager } from '../environment/manager';
+import * as fs from 'fs';
 import * as vscode from 'vscode';
 import * as envDetection from '../utils/envDetection';
 import * as envVersion from '../utils/envVersion';
 import { getLspManager, createAndStartLsp } from '../extension';
 
 // ── Module Mocks ──────────────────────────────────────────────────────────────
 
+// Keep real fs behavior, but make existsSync overridable for getPythonPath tests.
+jest.mock('fs', () => ({
+    ...jest.requireActual('fs'),
+    existsSync: jest.fn(jest.requireActual('fs').existsSync),
+}));
+
 jest.mock('vscode-languageclient/node', () => ({
     LanguageClient: class {
         start = jest.fn();
@@ -415,12 +422,21 @@ describe('EnvManager', () => {
     });
 
     describe('getPythonPath()', () => {
-        test('returns python in the same directory as the configured jac executable', () => {
+        test('returns the sibling python when it exists (venv/conda install)', () => {
+            (fs.existsSync as jest.Mock).mockReturnValue(true);
             (envManager as any).jacPath = '/home/user/.venv/bin/jac';
             const expected = process.platform === 'win32'
                 ? '/home/user/.venv/bin/python.exe'
                 : '/home/user/.venv/bin/python';
             expect(envManager.getPythonPath()).toBe(expected);
+            (fs.existsSync as jest.Mock).mockReset();
+        });
+
+        test('returns bare python when no sibling exists (single binary install)', () => {
+            (fs.existsSync as jest.Mock).mockReturnValue(false);
+            (envManager as any).jacPath = '/home/user/.local/bin/jac';
+            expect(envManager.getPythonPath()).toBe(process.platform === 'win32' ? 'python.exe' : 'python');
+            (fs.existsSync as jest.Mock).mockReset();
         });
 
         test('falls back to the platform default when no path is configured', () => {

src/environment/manager.ts

@@ -1,4 +1,5 @@
 import * as vscode from 'vscode';
+import * as fs from 'fs';
 import * as path from 'path';
 import { discoverJacEnvironments, validateJacExecutable, JacEnvironment } from '../utils/envDetection';
 import { getJacVersion, compareVersions } from '../utils/envVersion';
@@ -90,12 +91,17 @@ export class EnvManager {
     }
 
     getPythonPath(): string {
+        const pythonExe = process.platform === 'win32' ? 'python.exe' : 'python';
         if (this.jacPath) {
-            const jacDir = path.dirname(this.jacPath);
-            const pythonExe = process.platform === 'win32' ? 'python.exe' : 'python';
-            return path.join(jacDir, pythonExe);
+            // Legacy pip venv ships a sibling python in bin/; use it when present.
+            const sibling = path.join(path.dirname(this.jacPath), pythonExe);
+            if (fs.existsSync(sibling)) { return sibling; }
+
+            // Single binary (any install location - .local, brew, /usr/local) has
+            // Python embedded, so there is no sibling. Fall back to bare python.
+            return pythonExe;
         }
-        return process.platform === 'win32' ? 'python.exe' : 'python';
+        return pythonExe;
     }
 
     getStatusBar(): vscode.StatusBarItem {
@@ -253,7 +259,7 @@ export class EnvManager {
         const typeLabel = envType.charAt(0).toUpperCase() + envType.slice(1);
 
         const versionStr = version ? `Jac ${version}` : 'Jac';
-        const namePart = envName ? ` (${envName})` : '';
+        const namePart = envType === 'global' ? '' : envName ? ` (${envName})` : '';
         const label = `${isActive ? '$(check) ' : ''}${versionStr}${namePart}`;
         const description = `${this.formatPath(envPath)}  ·  ${typeLabel}`;
 

src/utils/envDetection.ts

@@ -1,6 +1,7 @@
 import * as fs from 'fs/promises';
 import type { Dirent } from 'fs';
 import * as path from 'path';
+import * as os from 'os';
 
 // ── Constants ─────────────────────────────────────────────────────────────────
 
@@ -63,6 +64,26 @@ async function walkForVenvs(baseDir: string, depth: number): Promise<string[]> {
 
 // ── Environment Locators ─────────────────────────────────────────────────────
 
+// Locator 0: Checks well-known single-binary install locations directly - catches
+// fresh installs before the install dir is on PATH. Cross-platform.
+async function findDefaultBinary(): Promise<string[]> {
+    const home = os.homedir();
+    const candidates = process.platform === 'win32'
+        ? [
+            path.join(process.env.LOCALAPPDATA ?? path.join(home, 'AppData', 'Local'), 'Programs', 'jac', 'jac.exe'),
+            path.join(process.env.LOCALAPPDATA ?? path.join(home, 'AppData', 'Local'), 'jac', 'bin', 'jac.exe'),
+        ]
+        : [
+            path.join(home, '.local', 'bin', 'jac'),
+            '/opt/homebrew/bin/jac', // macOS arm brew
+            '/usr/local/bin/jac',
+        ];
+    const results = await Promise.all(
+        candidates.map(async c => (await fileExists(c)) ? c : null)
+    );
+    return results.filter((c): c is string => c !== null);
+}
+
 // Locator 1: Scans $PATH for jac
 async function findInPath(): Promise<string[]> {
     const isWin = process.platform === 'win32';
@@ -149,7 +170,8 @@ export interface JacEnvironment {
 
 // Discovers all Jac environments on-demand (~10-15ms)
 export async function discoverJacEnvironments(workspaceRoots: string[]): Promise<JacEnvironment[]> {
-    const [pathEnvs, condaEnvs, homeEnvs, ...workspaceResults] = await Promise.all([
+    const [defaultBinaries, pathEnvs, condaEnvs, homeEnvs, ...workspaceResults] = await Promise.all([
+        findDefaultBinary(),
         findInPath(),
         findInCondaEnvs(),
         findInHome(),
@@ -167,8 +189,9 @@ export async function discoverJacEnvironments(workspaceRoots: string[]): Promise
         }
     };
 
-    // Priority: workspace > global > conda > home venvs
+    // Priority: workspace > default binary (~/.local/bin) > PATH > conda > home venvs
     workspaceEnvs.forEach(envPath => add(envPath, 'workspace'));
+    defaultBinaries.forEach(envPath => add(envPath, 'global'));
     pathEnvs.forEach(envPath => add(envPath, 'global'));
     condaEnvs.forEach(envPath => add(envPath, 'conda'));
     homeEnvs.forEach(envPath => add(envPath, 'venv'));

src/utils/envVersion.ts

@@ -1,35 +1,52 @@
 import * as fs from 'fs/promises';
 import * as path from 'path';
+import * as os from 'os';
+import { execFile } from 'child_process';
+import { promisify } from 'util';
 
-// Finds jaclang version by scanning site-packages for a jaclang-*.dist-info folder (~1ms, no subprocess).
-// Returns undefined if version cannot be determined.
-export async function getJacVersion(jacPath: string): Promise<string | undefined> {
-    try {
-        const envRoot = path.dirname(path.dirname(jacPath));
-        const libDir  = path.join(envRoot, 'lib');
-
-        let libEntries: string[];
-        try { libEntries = await fs.readdir(libDir); }
-        catch { return undefined; }
-
-        for (const libEntry of libEntries.filter(entry => entry.startsWith('python'))) {
-            for (const pkgDir of ['site-packages', 'dist-packages']) {
-                try {
-                    const sitePackages = path.join(libDir, libEntry, pkgDir);
-                    const siteEntries  = await fs.readdir(sitePackages);
-                    const distInfoDir  = siteEntries.find(
-                        entry => entry.startsWith('jaclang-') && entry.endsWith('.dist-info')
-                    );
-                    if (distInfoDir) {
-                        return distInfoDir.slice('jaclang-'.length, -'.dist-info'.length);
-                    }
-                } catch { continue; }
-            }
+const execFileAsync = promisify(execFile);
+
+// Fast path: read version from ~/.cache/jac/rt/*/site/jaclang-*.dist-info (~0.002s).
+async function getJacVersionFromCache(): Promise<string | undefined> {
+    const cacheBase = process.env.XDG_CACHE_HOME ?? path.join(os.homedir(), '.cache');
+    const rtDir = path.join(cacheBase, 'jac', 'rt');
+
+    let hashDirs: string[];
+    try { hashDirs = await fs.readdir(rtDir); }
+    catch { return undefined; }
+
+    const versions: string[] = [];
+
+    for (const hashDir of hashDirs) {
+        const siteDir = path.join(rtDir, hashDir, 'site');
+        let entries: string[];
+        try { entries = await fs.readdir(siteDir); }
+        catch { continue; }
+
+        const distInfo = entries.find(e => e.startsWith('jaclang-') && e.endsWith('.dist-info'));
+        if (distInfo) {
+            versions.push(distInfo.slice('jaclang-'.length, -'.dist-info'.length));
         }
-        return undefined;
+    }
+
+    // Ambiguous if multiple distinct versions (e.g. dev + release) — fall back to subprocess.
+    const unique = [...new Set(versions)];
+    return unique.length === 1 ? unique[0] : undefined;
+}
+
+// Slow fallback (~1.8s): only runs if cache is missing (first-ever launch).
+async function getJacVersionFromBinary(jacPath: string): Promise<string | undefined> {
+    try {
+        const { stdout } = await execFileAsync(jacPath, ['--version'], { timeout: 5000 });
+        return stdout.match(/Version:\s+([\d.]+)/)?.[1];
     } catch { return undefined; }
 }
 
+// Cache first, subprocess fallback if cache is missing.
+export async function getJacVersion(jacPath: string): Promise<string | undefined> {
+    return (await getJacVersionFromCache()) ?? (await getJacVersionFromBinary(jacPath));
+}
+
 // Compares two semver strings. Returns positive if a > b, negative if a < b, 0 if equal.
 export function compareVersions(a: string, b: string): number {
     const aParts = a.split('.').map(Number);