chore: merge branch 'main' into feat/protect-options-formatting

Author: mcanouil

apps/vscode/CHANGELOG.md

@@ -1,8 +1,14 @@
 # Changelog
 
-## 1.126.0 (Unreleased)
+## 1.127.0 (Unreleased)
 
-## 1.125.0 (Release on 2025-09-03)
+- Added a new setting `quarto.useBundledQuartoInPositron` to prefer the Quarto CLI bundled with Positron when available. This setting has precedence _between_ `quarto.path` and `quarto.usePipQuarto`, and has no effect outside of Positron (<https://github.com/quarto-dev/quarto/pull/841>).
+
+## 1.126.0 (Release on 2025-10-08)
+
+- Fixed a bug opening non-Quarto files in visual mode on saving (<https://github.com/quarto-dev/quarto/pull/848>).
+
+## 1.125.0 (Release on 2025-10-03)
 
 - Fixed an issue where attribute values containing '='s could be truncated in some scenarios (<https://github.com/quarto-dev/quarto/pull/814>).
 - Fixed an issue where a loading spinner for qmd previews wasn't dismissed on preview errors (<https://github.com/quarto-dev/quarto/pull/823>).

apps/vscode/package.json

@@ -11,7 +11,7 @@
     "pandoc",
     "quarto"
   ],
-  "version": "1.126.0",
+  "version": "1.127.0",
   "repository": {
     "type": "git",
     "url": "https://github.com/quarto-dev/quarto/tree/main/apps/vscode"
@@ -1105,7 +1105,13 @@
           "order": 11,
           "type": "boolean",
           "default": true,
-          "markdownDescription": "When using a venv or conda environment, prefer Quarto CLI installed with pip in that environment. This will override Quarto CLI in the `PATH`, but not an explicitly configured `#quarto.path#`."
+          "markdownDescription": "When using a venv or conda environment, prefer Quarto CLI installed with pip in that environment. This will override Quarto CLI in the `PATH`, but not an explicitly configured `#quarto.path#` or the bundled Quarto when `#quarto.useBundledQuartoInPositron#` is enabled."
+        },
+        "quarto.useBundledQuartoInPositron": {
+          "order": 11,
+          "type": "boolean",
+          "default": false,
+          "markdownDescription": "When in Positron, prefer the bundled Quarto CLI provided by the IDE. This will override Quarto CLI from `quarto.usePipQuarto` and in the `PATH`, but not an explicitly configured `#quarto.path#`. Note that this setting has no effect outside of Positron."
         },
         "quarto.render.renderOnSave": {
           "order": 12,
@@ -1446,6 +1452,7 @@
     "nanoid": "^4.0.0",
     "p-queue": "^8.0.1",
     "picomatch": "^2.3.1",
+    "@posit-dev/positron": "^0.1.0",
     "quarto-core": "*",
     "quarto-lsp": "*",
     "quarto-vscode-editor": "*",

apps/vscode/src/core/quarto.ts

@@ -17,6 +17,7 @@ import * as path from "node:path";
 import * as fs from "node:fs";
 
 import { window, env, workspace, Uri } from "vscode";
+import { tryAcquirePositronApi } from "@posit-dev/positron";
 import { QuartoContext } from "quarto-core";
 import { activePythonInterpreter, pythonIsCondaEnv, pythonIsVenv } from "./python";
 import { isWindows } from "./platform";
@@ -35,6 +36,38 @@ export async function configuredQuartoPath() {
     return quartoPath;
   }
 
+  // check if we should use bundled Quarto in Positron
+  const useBundledQuarto = config.get("useBundledQuartoInPositron", false); // Default is now false
+  if (useBundledQuarto) {
+    // Check if we're in Positron
+    const isPositron = tryAcquirePositronApi();
+
+    if (isPositron) {
+      // Use path relative to the application root for Positron's bundled Quarto
+      const rootPath = env.appRoot; // Use vscode.env.appRoot as the application root path
+      const positronQuartoPath = path.join(
+        rootPath,
+        "quarto",
+        "bin",
+        isWindows() ? "quarto.exe" : "quarto"
+      );
+
+      if (fs.existsSync(positronQuartoPath)) {
+        return positronQuartoPath;
+      } else {
+        // Log error when bundled Quarto can't be found
+        console.error(
+          `useBundledQuartoInPositron is enabled but bundled Quarto not found at expected path: ${positronQuartoPath}. ` +
+          `Verify Quarto is bundled in the Positron installation.`
+        );
+
+        window.showWarningMessage(
+          "Unable to find bundled Quarto in Positron; falling back to system installation"
+        );
+      }
+    }
+  }
+
   // if we can use pip quarto then look for it within the currently python (if its a venv/condaenv)
   const usePipQuarto = config.get("usePipQuarto", true);
   if (usePipQuarto) {

apps/vscode/src/main.ts

@@ -15,6 +15,7 @@
 
 import * as vscode from "vscode";
 import * as path from "path";
+import { tryAcquirePositronApi } from "@posit-dev/positron";
 import { MarkdownEngine } from "./markdown/engine";
 import { kQuartoDocSelector } from "./core/doc";
 import { activateLsp, deactivate as deactivateLsp } from "./lsp/client";
@@ -60,7 +61,7 @@ export async function activate(context: vscode.ExtensionContext) {
     quartoPath,
     workspaceFolder,
     // Look for quarto in the app root; this is where Positron installs it
-    [path.join(vscode.env.appRoot, 'quarto', 'bin')],
+    [path.join(vscode.env.appRoot, "quarto", "bin")],
     vscode.window.showWarningMessage
   );
   if (quartoContext.available) {
@@ -129,9 +130,53 @@ export async function activate(context: vscode.ExtensionContext) {
   // activate providers common to browser/node
   activateCommon(context, host, engine, commands);
 
+  // Register configuration change listener for Quarto path settings
+  registerQuartoPathConfigListener(context, outputChannel);
+
   outputChannel.info("Activated Quarto extension.");
 }
 
+/**
+ * Register a listener for changes to Quarto path settings that require a restart
+ */
+function registerQuartoPathConfigListener(context: vscode.ExtensionContext, outputChannel: vscode.LogOutputChannel) {
+  // Check if we're in Positron
+  const isPositron = tryAcquirePositronApi();
+
+  // List of settings that require restart when changed
+  const quartoPathSettings = [
+    "quarto.path",
+    "quarto.usePipQuarto",
+  ];
+  const positronPathSettings = [
+    "quarto.useBundledQuartoInPositron"
+  ];
+
+  // Listen for configuration changes
+  context.subscriptions.push(
+    vscode.workspace.onDidChangeConfiguration(event => {
+      // Check if any of our path settings changed
+      const requiresRestart = quartoPathSettings.some(setting => event.affectsConfiguration(setting));
+      const requiresPositronRestart = isPositron && positronPathSettings.some(setting => event.affectsConfiguration(setting));
+
+      if (requiresRestart || requiresPositronRestart) {
+        outputChannel.info(`Quarto path settings changed, restart required: ${quartoPathSettings.filter(setting =>
+          event.affectsConfiguration(setting)).join(", ")}`);
+
+        // Prompt user to restart
+        vscode.window.showInformationMessage(
+          "Quarto path settings have changed. Please reload the window for changes to take effect.",
+          "Reload Window"
+        ).then(selection => {
+          if (selection === "Reload Window") {
+            vscode.commands.executeCommand("workbench.action.reloadWindow");
+          }
+        });
+      }
+    })
+  );
+}
+
 export async function deactivate() {
   return deactivateLsp();
 }

apps/vscode/src/providers/editor/toggle.ts

@@ -129,18 +129,18 @@ export async function reopenEditorInVisualMode(
     // reopen in visual mode
     commands.executeCommand('positron.reopenWith', document.uri, 'quarto.visualEditor');
   } else {
-    workspace.onDidSaveTextDocument(async (doc: TextDocument) => {
-      // open in visual mode
-      VisualEditorProvider.recordPendingSwitchToVisual(doc);
-      await commands.executeCommand('workbench.action.closeActiveEditor');
-      await commands.executeCommand("vscode.openWith",
-        doc.uri,
-        VisualEditorProvider.viewType,
-        { viewColumn }
-      );
-    });
-    // save, which will trigger `onDidSaveTextDocument`
+    // save then close
     await commands.executeCommand("workbench.action.files.save");
+    await commands.executeCommand('workbench.action.closeActiveEditor');
+    VisualEditorProvider.recordPendingSwitchToVisual(document);
+
+    // open in visual mode
+    await commands.executeCommand(
+      "vscode.openWith",
+      document.uri,
+      VisualEditorProvider.viewType,
+      { viewColumn }
+    );
   }
 }
 

apps/vscode/src/test/examples/hello.lua

@@ -0,0 +1 @@
+print("Hello World")

apps/vscode/src/test/quartoDoc.test.ts

@@ -41,6 +41,20 @@ suite("Quarto basics", function () {
   roundtripSnapshotTest('capsule-leak.qmd');
 
   roundtripSnapshotTest('attr-equals.qmd');
+
+  // a test to prevent situations like https://github.com/quarto-dev/quarto/issues/845
+  test("Can open a non-qmd file normally", async function () {
+    const { editor, doc } = await openAndShowTextDocument("hello.lua");
+
+    editor.edit((editBuilder) => {
+      editBuilder.insert(new vscode.Position(0, 0), 'print("hiyo")\n');
+    });
+    doc.save();
+
+    await wait(1700); // approximate time to open visual editor, just in case
+
+    assert.equal(vscode.window.activeTextEditor, editor, 'quarto extension interferes with other files opened in VSCode!');
+  });
 });
 
 /**

claude.md

@@ -0,0 +1,64 @@
+# Quarto Development Guide
+
+## Project Overview
+
+Quarto is an open-source scientific and technical publishing system built on [Pandoc](https://pandoc.org). This repository contains the source code for various parts of the Quarto ecosystem, with the main CLI implementation housed in a separate repository ([quarto-cli](https://github.com/quarto-dev/quarto-cli)).
+
+### Main Components
+
+- **VS Code Extension**: The primary VS Code extension for working with Quarto documents
+- **Writer**: An experimental web-based editor for Quarto documents (not used in production yet)
+- **LSP**: Language server for Quarto documents
+- **Core Packages**: Shared libraries used across multiple components
+
+## Development Workflow
+
+Each component has specific development guidelines. Refer to the corresponding CONTRIBUTING.md files:
+
+- VS Code extension: [apps/vscode/CONTRIBUTING.md](apps/vscode/CONTRIBUTING.md) - Contains detailed instructions for building, debugging, and releasing the extension
+
+## Repository Structure
+
+The repository is organized as a monorepo using Yarn workspaces and Turborepo for build orchestration:
+
+- `apps/`: Contains standalone applications
+  - `vscode/`: VS Code extension for Quarto
+  - `writer/`: Experimental web-based Quarto editor (not in production, ignore this for now)
+  - `lsp/`: Language Server Protocol implementation
+  - `panmirror/`: WYSIWYG editor component
+- `packages/`: Contains shared libraries
+  - `core/`: Core functionality shared across packages
+  - `editor-*/`: Editor-related packages
+  - `quarto-core/`: Quarto-specific core functionality
+  - Other utility packages
+
+## Build System
+
+Quarto uses [turborepo](https://turbo.build/) to manage the monorepo build process:
+
+- `turbo.json`: Defines the pipeline configuration for common tasks
+- Common commands:
+  - `yarn build`: Builds all packages and applications
+  - `yarn dev-writer`: Runs the writer app in development mode
+  - `yarn dev-vscode`: Runs the VS Code extension in development mode
+  - `yarn lint`: Runs linters across all workspaces
+  - `yarn build-vscode`: Builds only the VS Code extension and its dependencies
+
+The turborepo pipeline helps optimize build times by caching build artifacts and respecting the dependency graph between packages.
+
+## Testing
+
+Testing procedures vary by component:
+
+- VS Code extension: Run `yarn test-vscode` to compile test files and run them with the vscode-test CLI
+- Other components have specific test commands defined in their respective package.json files
+
+
+## Additional Resources
+
+- [Quarto Website](https://quarto.org)
+- [Extension on Microsoft marketplace](https://marketplace.visualstudio.com/items?itemName=quarto.quarto)
+- [Extension on Open VSX Registry](https://open-vsx.org/extension/quarto/quarto)
+- [Quarto GitHub Organization](https://github.com/quarto-dev)
+
+# Instructions