Use environment from defaultInterpreterPath if not set (#10)

Author: renan-r-santos

package-lock.json

@@ -4,7 +4,7 @@
     "description": "Pixi support for the Python Environments extension",
     "icon": "assets/icon.png",
     "license": "MIT",
-    "version": "0.1.2",
+    "version": "0.1.3",
     "homepage": "https://github.com/renan-r-santos/pixi-code",
     "repository": {
         "type": "git",
@@ -20,7 +20,7 @@
         "conda"
     ],
     "engines": {
-        "vscode": "^1.102.0"
+        "vscode": "^1.103.0"
     },
     "categories": [
         "Data Science",
@@ -71,18 +71,18 @@
         "format:check": "prettier --check ."
     },
     "devDependencies": {
-        "@types/node": "20.x",
-        "@types/vscode": "^1.102.0",
+        "@types/node": "24.x",
+        "@types/vscode": "^1.103.0",
         "@types/which": "^3.0.4",
-        "@typescript-eslint/eslint-plugin": "^8.31.1",
-        "@typescript-eslint/parser": "^8.31.1",
-        "eslint": "^9.25.1",
+        "@typescript-eslint/eslint-plugin": "^8.40.0",
+        "@typescript-eslint/parser": "^8.40.0",
+        "eslint": "^9.34.0",
         "eslint-plugin-simple-import-sort": "^12.1.1",
-        "eslint-plugin-unused-imports": "^4.1.4",
-        "prettier": "^3.4.2",
-        "ts-loader": "^9.5.2",
-        "typescript": "^5.8.3",
-        "webpack": "^5.99.7",
+        "eslint-plugin-unused-imports": "^4.2.0",
+        "prettier": "^3.6.2",
+        "ts-loader": "^9.5.4",
+        "typescript": "^5.9.2",
+        "webpack": "^5.101.3",
         "webpack-cli": "^6.0.1"
     },
     "dependencies": {

package.json

@@ -0,0 +1,18 @@
+import * as path from 'path';
+import { workspace } from 'vscode';
+
+import { PythonProject } from '../api';
+import { expandVariables } from './variableExpansion';
+
+export function getDefaultInterpreterPath(project: PythonProject): string | undefined {
+    const defaultInterpreterPath = workspace
+        .getConfiguration('python', project.uri)
+        .get<string>('defaultInterpreterPath');
+
+    if (!defaultInterpreterPath) {
+        return undefined;
+    }
+
+    const expandedPath = expandVariables(defaultInterpreterPath, project.uri);
+    return path.resolve(project.uri.fsPath, expandedPath);
+}

src/common/defaultInterpreter.ts

@@ -0,0 +1,43 @@
+import { Uri, workspace } from 'vscode';
+
+export function expandVariables(value: string, project?: Uri, env?: { [key: string]: string }): string {
+    const substitutions = new Map<string, string>();
+
+    const home = process.env.HOME || process.env.USERPROFILE;
+    if (home) {
+        substitutions.set('${userHome}', home);
+    }
+
+    if (project) {
+        substitutions.set('${pythonProject}', project.fsPath);
+    }
+
+    const ws = project ? workspace.getWorkspaceFolder(project) : undefined;
+    if (ws) {
+        substitutions.set('${workspaceFolder}', ws.uri.fsPath);
+    }
+
+    substitutions.set('${cwd}', process.cwd());
+
+    (workspace.workspaceFolders ?? []).forEach((w) => {
+        substitutions.set('${workspaceFolder:' + w.name + '}', w.uri.fsPath);
+    });
+
+    const substEnv = env || process.env;
+    if (substEnv) {
+        for (const [key, value] of Object.entries(substEnv)) {
+            if (value && key.length > 0) {
+                substitutions.set('${env:' + key + '}', value);
+            }
+        }
+    }
+
+    let result = value;
+    substitutions.forEach((v, k) => {
+        while (k.length > 0 && result.indexOf(k) >= 0) {
+            result = result.replace(k, v);
+        }
+    });
+
+    return result;
+}

src/common/variableExpansion.ts

@@ -1,3 +1,4 @@
+import * as path from 'path';
 import { EventEmitter, LogOutputChannel, MarkdownString, ProgressLocation, ThemeIcon, Uri, window } from 'vscode';
 
 import {
@@ -12,11 +13,13 @@ import {
     IconPath,
     PythonEnvironment,
     PythonEnvironmentApi,
+    PythonProject,
     QuickCreateConfig,
     RefreshEnvironmentsScope,
     ResolveEnvironmentContext,
     SetEnvironmentScope,
 } from '../api';
+import { getDefaultInterpreterPath } from '../common/defaultInterpreter';
 import { createDeferred, Deferred } from '../common/deferred';
 import { traceVerbose } from '../common/logging';
 import { EXTENSION_ID } from '../common/utils';
@@ -140,7 +143,7 @@ export class PixiEnvManager implements EnvironmentManager {
             return this.projectToEnvs.get(project.uri.fsPath) || [];
         }
 
-        // Skip 'global'. Pixi does not have the notion of global or base environments like Conda
+        // Skip 'global'. Pixi does not have global or base environments like Conda
         return [];
     }
 
@@ -227,6 +230,9 @@ export class PixiEnvManager implements EnvironmentManager {
                     const projectPath = project.uri.fsPath;
 
                     const newEnvs = await refreshPixi(projectPath);
+                    const defaultEnvs = await this.getDefaultPathEnvironments(project);
+                    newEnvs.push(...defaultEnvs);
+
                     const oldEnvs = oldProjectToEnvs.get(projectPath) || [];
 
                     const oldEnvIds = new Set(oldEnvs.map((env) => env.envId.id));
@@ -264,9 +270,12 @@ export class PixiEnvManager implements EnvironmentManager {
                     const projectPath = project.uri.fsPath;
 
                     const envId = await getProjectEnvId(projectPath);
-                    const env = envId ? envIdToEnv.get(envId) : undefined;
+                    let env = envId ? envIdToEnv.get(envId) : undefined;
+
                     if (env) {
                         this.activeEnv.set(projectPath, env);
+                    } else {
+                        env = await this.trySetActiveFromDefault(project, projectPath);
                     }
 
                     this.triggerDidChangeEnvironment(project.uri, oldActiveEnv.get(projectPath), env);
@@ -285,6 +294,8 @@ export class PixiEnvManager implements EnvironmentManager {
 
         const oldEnvs = this.projectToEnvs.get(projectPath) || [];
         const newEnvs = await refreshPixi(projectPath);
+        const defaultEnvs = await this.getDefaultPathEnvironments(project);
+        newEnvs.push(...defaultEnvs);
 
         const oldEnvIds = new Set(oldEnvs.map((env) => env.envId.id));
         const newEnvIds = new Set(newEnvs.map((env) => env.envId.id));
@@ -309,11 +320,51 @@ export class PixiEnvManager implements EnvironmentManager {
         );
 
         const envId = await getProjectEnvId(projectPath);
-        const env = envId ? envIdToEnv.get(envId) : undefined;
+        let env = envId ? envIdToEnv.get(envId) : undefined;
         this.triggerDidChangeEnvironment(project.uri, this.activeEnv.get(projectPath), env);
+
         if (env) {
             this.activeEnv.set(projectPath, env);
+        } else {
+            env = await this.trySetActiveFromDefault(project, projectPath);
+        }
+    }
+
+    private async getDefaultPathEnvironments(project: PythonProject): Promise<PixiEnvironment[]> {
+        const defaultInterpreterPath = getDefaultInterpreterPath(project);
+
+        if (!defaultInterpreterPath) {
+            return [];
         }
+
+        const binPath = path.dirname(defaultInterpreterPath);
+        traceVerbose(`Also refreshing Pixi environments using defaultInterpreterPath: ${binPath}`);
+        return await refreshPixi(binPath);
+    }
+
+    private async trySetActiveFromDefault(
+        project: PythonProject,
+        projectPath: string,
+    ): Promise<PixiEnvironment | undefined> {
+        const defaultInterpreterPath = getDefaultInterpreterPath(project);
+
+        if (defaultInterpreterPath) {
+            const projectEnvs = this.projectToEnvs.get(projectPath) || [];
+            const matchingEnv = projectEnvs.find((env) =>
+                defaultInterpreterPath.startsWith(env.environmentPath.fsPath),
+            );
+
+            if (matchingEnv) {
+                traceVerbose(
+                    `Setting active environment for project ${projectPath} based on default interpreter path ${defaultInterpreterPath}`,
+                );
+                this.activeEnv.set(projectPath, matchingEnv);
+                await setProjectEnvId(projectPath, matchingEnv.envId.id);
+                return matchingEnv;
+            }
+        }
+
+        return undefined;
     }
 
     private triggerDidChangeEnvironment(

src/pixi/envManager.ts

@@ -66,6 +66,11 @@ export class PixiPackageManager implements PackageManager, Disposable {
                 title: 'Refreshing Pixi packages',
             },
             async () => {
+                if (!environment.pixiInfo.project_info) {
+                    traceVerbose('No project info found in pixiInfo; skipping package refresh.');
+                    return;
+                }
+
                 const manifest_path = environment.pixiInfo.project_info.manifest_path;
                 const project_path = path.dirname(manifest_path);
 

src/pixi/projectManager.ts

@@ -1,7 +1,7 @@
 import { Package, PythonEnvironment } from '../api';
 
 export interface PixiInfo {
-    project_info: {
+    project_info?: {
         name: string;
         manifest_path: string;
     };

src/pixi/types.ts

@@ -6,7 +6,7 @@ import { Package } from '../api';
 import { createDeferred } from '../common/deferred';
 import { quoteArgs } from '../common/execUtils';
 import { findPythonExecutable } from '../common/findPython';
-import { traceError, traceInfo } from '../common/logging';
+import { traceError, traceInfo, traceVerbose } from '../common/logging';
 import { getWorkspacePersistentState } from '../common/persistentState';
 import { EXTENSION_ID, untildify } from '../common/utils';
 import { PixiEnvironment, PixiInfo, PixiPackage } from './types';
@@ -92,6 +92,12 @@ export async function refreshPixi(project_path: string): Promise<PixiEnvironment
 
         const stdout = await runPixi(['info', '--json'], { cwd: project_path });
         const pixiInfo: PixiInfo = JSON.parse(stdout);
+
+        if (!pixiInfo.project_info) {
+            traceVerbose(`No project info found for Pixi project at ${project_path}`);
+            return [];
+        }
+
         const projectName = pixiInfo.project_info.name;
         const manifestPath = pixiInfo.project_info.manifest_path;