Implement terminal reuse functionality with configuration option

Co-authored-by: anthonykim1 <[email protected]>

Author: Copilot

package.json

@@ -633,6 +633,12 @@
                         "preview"
                     ]
                 },
+                "python.terminal.reuseActiveTerminal": {
+                    "default": true,
+                    "description": "%python.terminal.reuseActiveTerminal.description%",
+                    "scope": "resource",
+                    "type": "boolean"
+                },
                 "python.REPL.enableREPLSmartSend": {
                     "default": true,
                     "description": "%python.EnableREPLSmartSend.description%",

package.nls.json

@@ -77,6 +77,7 @@
     "python.terminal.executeInFileDir.description": "When executing a file in the terminal, whether to use execute in the file's directory, instead of the current open folder.",
     "python.terminal.focusAfterLaunch.description": "When launching a python terminal, whether to focus the cursor on the terminal.",
     "python.terminal.launchArgs.description": "Python launch arguments to use when executing a file in the terminal.",
+    "python.terminal.reuseActiveTerminal.description": "When running code selections or lines, try to reuse an existing active Python terminal instead of creating a new one.",
     "python.testing.autoTestDiscoverOnSaveEnabled.description": "Enable auto run test discovery when saving a test file.",
     "python.testing.autoTestDiscoverOnSavePattern.description": "Glob pattern used to determine which files are used by autoTestDiscoverOnSaveEnabled.",
     "python.testing.cwd.description": "Optional working directory for tests.",

src/client/common/configSettings.ts

@@ -378,6 +378,7 @@ export class PythonSettings implements IPythonSettings {
                   activateEnvironment: true,
                   activateEnvInCurrentTerminal: false,
                   enableShellIntegration: false,
+                  reuseActiveTerminal: true,
               };
 
         this.REPL = pythonSettings.get<IREPLSettings>('REPL')!;

src/client/common/types.ts

@@ -189,6 +189,7 @@ export interface ITerminalSettings {
     readonly activateEnvironment: boolean;
     readonly activateEnvInCurrentTerminal: boolean;
     readonly enableShellIntegration: boolean;
+    readonly reuseActiveTerminal: boolean;
 }
 
 export interface IREPLSettings {

src/client/terminals/codeExecution/terminalCodeExecution.ts

@@ -5,7 +5,7 @@
 
 import { inject, injectable } from 'inversify';
 import * as path from 'path';
-import { Disposable, Uri } from 'vscode';
+import { Disposable, Uri, window, Terminal } from 'vscode';
 import { IApplicationShell, ICommandManager, IWorkspaceService } from '../../common/application/types';
 import '../../common/extensions';
 import { IPlatformService } from '../../common/platform/types';
@@ -25,6 +25,7 @@ export class TerminalCodeExecutionProvider implements ICodeExecutionService {
     private hasRanOutsideCurrentDrive = false;
     protected terminalTitle!: string;
     private replActive?: Promise<boolean>;
+    private existingReplTerminal?: Terminal;
 
     constructor(
         @inject(ITerminalServiceFactory) protected readonly terminalServiceFactory: ITerminalServiceFactory,
@@ -59,11 +60,39 @@ export class TerminalCodeExecutionProvider implements ICodeExecutionService {
                 this.configurationService.updateSetting('REPL.enableREPLSmartSend', false, resource);
             }
         } else {
-            await this.getTerminalService(resource).executeCommand(code, true);
+            // If we're using an existing terminal, send code directly to it
+            if (this.existingReplTerminal) {
+                this.existingReplTerminal.sendText(code);
+            } else {
+                await this.getTerminalService(resource).executeCommand(code, true);
+            }
         }
     }
 
     public async initializeRepl(resource: Resource) {
+        // First, try to find and reuse an existing Python terminal
+        const existingTerminal = await this.findExistingPythonTerminal(resource);
+        if (existingTerminal) {
+            // Store the existing terminal reference and show it
+            this.existingReplTerminal = existingTerminal;
+            existingTerminal.show();
+            this.replActive = Promise.resolve(true);
+            
+            // Listen for terminal close events to clear our reference
+            const terminalCloseListener = window.onDidCloseTerminal((closedTerminal) => {
+                if (closedTerminal === this.existingReplTerminal) {
+                    this.existingReplTerminal = undefined;
+                    this.replActive = undefined;
+                }
+            });
+            this.disposables.push(terminalCloseListener);
+            
+            return;
+        }
+
+        // Clear any existing terminal reference since we're creating a new one
+        this.existingReplTerminal = undefined;
+
         const terminalService = this.getTerminalService(resource);
         if (this.replActive && (await this.replActive)) {
             await terminalService.show();
@@ -124,6 +153,41 @@ export class TerminalCodeExecutionProvider implements ICodeExecutionService {
     public async getExecuteFileArgs(resource?: Uri, executeArgs: string[] = []): Promise<PythonExecInfo> {
         return this.getExecutableInfo(resource, executeArgs);
     }
+
+    /**
+     * Find an existing terminal that has a Python REPL running
+     */
+    private async findExistingPythonTerminal(resource?: Uri): Promise<Terminal | undefined> {
+        const pythonSettings = this.configurationService.getSettings(resource);
+        
+        // Check if the feature is enabled
+        if (!pythonSettings.terminal.reuseActiveTerminal) {
+            return undefined;
+        }
+
+        // Look through all existing terminals
+        for (const terminal of window.terminals) {
+            // Skip terminals that are closed or hidden
+            if (terminal.exitStatus) {
+                continue;
+            }
+
+            // Check if this looks like a Python terminal based on name
+            const terminalName = terminal.name.toLowerCase();
+            if (terminalName.includes('python') || terminalName.includes('repl')) {
+                // For now, we'll consider any Python-named terminal as potentially reusable
+                // In the future, we could add more sophisticated detection
+                return terminal;
+            }
+
+            // Check if the terminal's detected shell is Python
+            if (terminal.state?.shell === 'python') {
+                return terminal;
+            }
+        }
+
+        return undefined;
+    }
     private getTerminalService(resource: Resource, options?: { newTerminalPerFile: boolean }): ITerminalService {
         return this.terminalServiceFactory.getTerminalService({
             resource,

src/test/terminals/codeExecution/terminalCodeExec.unit.test.ts

@@ -675,4 +675,151 @@ suite('Terminal - Code Execution', () => {
             });
         });
     });
+
+    suite('Terminal Reuse', () => {
+        let terminalSettings: TypeMoq.IMock<ITerminalSettings>;
+        let terminalService: TypeMoq.IMock<ITerminalService>;
+        let workspace: TypeMoq.IMock<IWorkspaceService>;
+        let platform: TypeMoq.IMock<IPlatformService>;
+        let workspaceFolder: TypeMoq.IMock<WorkspaceFolder>;
+        let settings: TypeMoq.IMock<IPythonSettings>;
+        let disposables: Disposable[] = [];
+        let executor: ReplProvider;
+        let terminalFactory: TypeMoq.IMock<ITerminalServiceFactory>;
+        let commandManager: TypeMoq.IMock<ICommandManager>;
+        let applicationShell: TypeMoq.IMock<IApplicationShell>;
+        let interpreterService: TypeMoq.IMock<IInterpreterService>;
+        let windowStub: sinon.SinonStub;
+        let mockTerminals: any[];
+
+        setup(() => {
+            terminalFactory = TypeMoq.Mock.ofType<ITerminalServiceFactory>();
+            terminalService = TypeMoq.Mock.ofType<ITerminalService>();
+            const configService = TypeMoq.Mock.ofType<IConfigurationService>();
+            workspace = TypeMoq.Mock.ofType<IWorkspaceService>();
+            commandManager = TypeMoq.Mock.ofType<ICommandManager>();
+            applicationShell = TypeMoq.Mock.ofType<IApplicationShell>();
+            platform = TypeMoq.Mock.ofType<IPlatformService>();
+            interpreterService = TypeMoq.Mock.ofType<IInterpreterService>();
+
+            workspaceFolder = TypeMoq.Mock.ofType<WorkspaceFolder>();
+            workspaceFolder.setup((w) => w.uri).returns(() => Uri.file(__dirname));
+
+            terminalSettings = TypeMoq.Mock.ofType<ITerminalSettings>();
+            terminalSettings.setup((t) => t.reuseActiveTerminal).returns(() => true);
+            terminalSettings.setup((t) => t.activateEnvironment).returns(() => false);
+            terminalSettings.setup((t) => t.activateEnvInCurrentTerminal).returns(() => false);
+
+            settings = TypeMoq.Mock.ofType<IPythonSettings>();
+            settings.setup((s) => s.terminal).returns(() => terminalSettings.object);
+
+            configService.setup((c) => c.getSettings(TypeMoq.It.isAny())).returns(() => settings.object);
+
+            terminalFactory
+                .setup((f) => f.getTerminalService(TypeMoq.It.isAny()))
+                .returns(() => terminalService.object);
+
+            // Mock window.terminals using a stub
+            mockTerminals = [];
+            const vscode = require('vscode');
+            windowStub = sinon.stub(vscode, 'window').value({ 
+                terminals: mockTerminals,
+                onDidCloseTerminal: () => ({ dispose: () => {} })
+            });
+
+            executor = new ReplProvider(
+                terminalFactory.object,
+                configService.object,
+                workspace.object,
+                disposables,
+                platform.object,
+                interpreterService.object,
+                commandManager.object,
+                applicationShell.object,
+            );
+        });
+
+        teardown(() => {
+            disposables.forEach((d) => d.dispose());
+            disposables = [];
+            windowStub.restore();
+        });
+
+        test('Should reuse existing Python terminal when reuseActiveTerminal is enabled', async () => {
+            // Arrange
+            const mockTerminal = {
+                name: 'Python',
+                exitStatus: undefined,
+                show: sinon.stub(),
+                sendText: sinon.stub(),
+                state: { shell: 'python' }
+            };
+            mockTerminals.push(mockTerminal);
+
+            terminalSettings.setup((t) => t.reuseActiveTerminal).returns(() => true);
+
+            // Act
+            await executor.execute('print("hello")', Uri.file('test.py'));
+
+            // Assert
+            sinon.assert.calledOnce(mockTerminal.show);
+            sinon.assert.calledWith(mockTerminal.sendText, 'print("hello")');
+            terminalService.verify(async (t) => t.executeCommand(TypeMoq.It.isAny(), TypeMoq.It.isAny()), TypeMoq.Times.never());
+        });
+
+        test('Should not reuse existing terminal when reuseActiveTerminal is disabled', async () => {
+            // Arrange
+            const mockTerminal = {
+                name: 'Python',
+                exitStatus: undefined,
+                show: sinon.stub(),
+                sendText: sinon.stub(),
+                state: { shell: 'python' }
+            };
+            mockTerminals.push(mockTerminal);
+
+            terminalSettings.setup((t) => t.reuseActiveTerminal).returns(() => false);
+
+            // Mock required dependencies for creating new terminal
+            interpreterService
+                .setup((s) => s.getActiveInterpreter(TypeMoq.It.isAny()))
+                .returns(() => Promise.resolve(({ path: '/usr/bin/python' } as unknown) as PythonEnvironment));
+            terminalSettings.setup((t) => t.launchArgs).returns(() => []);
+            platform.setup((p) => p.isWindows).returns(() => false);
+
+            // Act
+            await executor.execute('print("hello")', Uri.file('test.py'));
+
+            // Assert
+            sinon.assert.notCalled(mockTerminal.show);
+            sinon.assert.notCalled(mockTerminal.sendText);
+        });
+
+        test('Should skip closed terminals when looking for reusable terminal', async () => {
+            // Arrange
+            const closedTerminal = {
+                name: 'Python',
+                exitStatus: { code: 0 },
+                show: sinon.stub(),
+                sendText: sinon.stub()
+            };
+            const activeTerminal = {
+                name: 'Python REPL',
+                exitStatus: undefined,
+                show: sinon.stub(),
+                sendText: sinon.stub()
+            };
+            mockTerminals.push(closedTerminal, activeTerminal);
+
+            terminalSettings.setup((t) => t.reuseActiveTerminal).returns(() => true);
+
+            // Act
+            await executor.execute('print("hello")', Uri.file('test.py'));
+
+            // Assert
+            sinon.assert.notCalled(closedTerminal.show);
+            sinon.assert.calledOnce(activeTerminal.show);
+            sinon.assert.calledWith(activeTerminal.sendText, 'print("hello")');
+        });
+    });
 });