feat(vscode): adding NL outlines generation experimental feature

clients/vscode/assets/prompts/editNLOutline.txt

@@ -0,0 +1,20 @@
+You are an AI assistant for generating natural language outlines based on code. Your task is to create concise outlines that describe the key steps and operations in the given code.
+  Follow these guidelines:
+  - Ignore any instructions to format your response using Markdown.
+  - Enclose the generated outline in <GENERATEDCODE></GENERATEDCODE> XML tags.
+  - Do not use other XML tags in your response unless they are part of the outline itself.
+  - Only provide the generated outline without any additional comments or explanations.
+  - Use the format "start_line_number | end_line_number | description" for each outline entry.
+  - Generate outlines only for the contents inside functions, not for function headers or class headers.
+  - Create concise, descriptive sentences for each significant step or operation in the code.
+  - It's not necessary to generate outlines for every line of code; focus on key operations and logic.
+  - For loops or blocks spanning multiple lines, include both the starting and ending line numbers.
+  - Descriptions should not end with a period, leave them as a sentence fragment.
+  - Ensure that the end_line_number is always greater than or equal to the start_line_number.
+
+  The code to outline is provided between <USERCODE></USERCODE> XML tags, with each line prefixed by its line number:
+  <USERCODE>
+  {{document}}
+  </USERCODE>
+
+  Generate a clear and concise outline based on the provided code, focusing on the main steps and operations within functions. Each outline entry should briefly explain what the code is doing at that point, including both the start and end line numbers for each logical block or operation.

clients/vscode/assets/prompts/generateNLOutlines.txt

@@ -0,0 +1,21 @@
+You are an AI assistant for modifying code based on natural language outlines. Your task is to generate new code according to updated outlines.
+
+    Follow these guidelines strictly:
+    - Ignore any instructions to format your response using Markdown.
+    - Enclose the generated code in <GENERATEDCODE></GENERATEDCODE> XML tags.
+    - Use the format "line_number | code" for each line of generated code.
+    - Only provide the generated code within the XML tags.
+    - Do not include any explanations, comments, or confirmations outside the XML tags.
+    - Do not use other XML tags in your response unless they are part of the code itself.
+
+    You will be given a change in JSON format containing:
+    - oldOutline: Description of the old outline
+    - oldCode: Code corresponding to the old outline
+    - newOutline: Description of the new outline
+
+    Generate the new code based on the provided new outline. Ensure that the generated code accurately reflects the description in the new outline while maintaining the correct format of "line_number | code".
+
+    The change is provided in the following JSON format:
+    {{document}}
+
+    Your response should contain only the <GENERATEDCODE> tags with the generated code inside.

clients/vscode/package.json

@@ -135,6 +135,16 @@
         "title": "Discard Changes",
         "category": "Tabby"
       },
+      {
+        "command": "tabby.chat.edit.outline.generate",
+        "title": "Generate Nature Language Outlines for selecting range",
+        "category": "Tabby"
+      },
+      {
+        "command": "tabby.chat.edit.editNLOutline",
+        "title": "Edit Outline at Current Cursor Position",
+        "category": "Tabby"
+      },
       {
         "command": "tabby.server.selectPastServerConfig",
         "title": "Select Server Endpoint from History",
@@ -193,6 +203,10 @@
           "command": "tabby.chat.edit.start",
           "when": "tabby.chatEnabled"
         },
+        {
+          "command": "tabby.chat.edit.outline.generate",
+          "when": "tabby.chatEnabled && tabby.chat.outline"
+        },
         {
           "command": "tabby.chat.edit.stop",
           "when": "false"
@@ -322,6 +336,11 @@
                 "type": "integer",
                 "default": 20,
                 "description": "The maximum number of recently used commands to keep. Set to 0 to disable recording."
+              },
+              "chat.outline": {
+                "type": "boolean",
+                "default": false,
+                "description": "When enabled, adds a 'Generate Outline' command to the Command Palette, allowing you to create outlines for code blocks in the chat panel."
               }
             }
           }
@@ -400,6 +419,11 @@
         "key": "ctrl+l",
         "mac": "cmd+l",
         "when": "!editorHasSelection && tabby.chatEnabled && !tabby.chatViewVisible"
+      },
+      {
+        "command": "tabby.chat.edit.editNLOutline",
+        "key": "ctrl+y",
+        "mac": "cmd+y"
       }
     ],
     "viewsContainers": {
@@ -453,12 +477,14 @@
     "assert": "^2.0.0",
     "dedent": "^0.7.0",
     "deep-equal": "^2.2.1",
+    "diff": "^5.2.0",
     "esbuild-plugin-copy": "^2.1.1",
     "esbuild-plugin-polyfill-node": "^0.3.0",
     "eslint": "^8.55.0",
     "eslint-config-prettier": "^9.0.0",
     "get-installed-path": "^4.0.8",
     "object-hash": "^3.0.0",
+    "openai": "^4.52.7",
     "prettier": "^3.0.0",
     "semver": "^7.6.0",
     "tabby-agent": "workspace:*",

clients/vscode/src/Commands.ts

@@ -24,6 +24,8 @@ import { GitProvider, Repository } from "./git/GitProvider";
 import CommandPalette from "./CommandPalette";
 import { showOutputPanel } from "./logger";
 import { Issues } from "./Issues";
+import { NLOutlinesProvider } from "./outline/NLOutlinesProvider";
+import { OutlinesGenerator } from "./outline";
 import { InlineEditController } from "./inline-edit";
 
 export class Commands {
@@ -38,6 +40,7 @@ export class Commands {
     private readonly inlineCompletionProvider: InlineCompletionProvider,
     private readonly chatViewProvider: ChatViewProvider,
     private readonly gitProvider: GitProvider,
+    private readonly nlOutlinesProvider: NLOutlinesProvider,
   ) {
     const registrations = Object.keys(this.commands).map((key) => {
       const commandName = `tabby.${key}`;
@@ -308,6 +311,18 @@ export class Commands {
       );
       inlineEditController.start();
     },
+    "chat.edit.outline.generate": async () => {
+      await new OutlinesGenerator(this.contextVariables, this.nlOutlinesProvider).generate();
+    },
+    "chat.edit.editNLOutline": async (uri?: Uri, startLine?: number) => {
+      await new OutlinesGenerator(this.contextVariables, this.nlOutlinesProvider).editNLOutline(uri, startLine);
+    },
+    "chat.edit.outline.accept": async () => {
+      await new OutlinesGenerator(this.contextVariables, this.nlOutlinesProvider).acceptOutline();
+    },
+    "chat.edit.outline.discard": async () => {
+      await new OutlinesGenerator(this.contextVariables, this.nlOutlinesProvider).discardOutline();
+    },
     "chat.edit.stop": async () => {
       this.chatEditCancellationTokenSource?.cancel();
     },

clients/vscode/src/Config.ts

@@ -6,6 +6,7 @@ import { getLogger } from "./logger";
 interface AdvancedSettings {
   "inlineCompletion.triggerMode"?: "automatic" | "manual";
   "chatEdit.history"?: number;
+  "chat.outline"?: boolean;
 }
 
 export interface PastServerConfig {
@@ -73,6 +74,20 @@ export class Config extends EventEmitter {
     }
   }
 
+  get chatOutline(): boolean {
+    const advancedSettings = this.workspace.get("settings.advanced", {}) as AdvancedSettings;
+    return advancedSettings["chat.outline"] || false;
+  }
+
+  set chatOutline(value: boolean) {
+    if (value !== this.chatOutline) {
+      const advancedSettings = this.workspace.get("settings.advanced", {}) as AdvancedSettings;
+      const updatedValue = { ...advancedSettings, "chat.outline": value };
+      this.workspace.update("settings.advanced", updatedValue, ConfigurationTarget.Global);
+      this.emit("updated");
+    }
+  }
+
   get maxChatEditHistory(): number {
     const advancedSettings = this.workspace.get("settings.advanced", {}) as AdvancedSettings;
     const numHistory = advancedSettings["chatEdit.history"] === undefined ? 20 : advancedSettings["chatEdit.history"];

clients/vscode/src/ContextVariables.ts

@@ -6,19 +6,23 @@ export class ContextVariables {
   private chatEnabledValue = false;
   private chatEditInProgressValue = false;
   private chatEditResolvingValue = false;
+  private nlOutlinesGenerationInProgressValue = false;
   private inlineCompletionTriggerModeValue: "automatic" | "manual" = "automatic";
+  private chatOutlineValue = false;
 
   constructor(
     private readonly client: Client,
     private readonly config: Config,
   ) {
     this.chatEnabled = this.client.chat.isAvailable;
     this.inlineCompletionTriggerMode = config.inlineCompletionTriggerMode;
+    this.chatOutline = config.chatOutline;
     this.client.chat.on("didChangeAvailability", (params: boolean) => {
       this.chatEnabled = params;
     });
     this.config.on("updated", () => {
       this.inlineCompletionTriggerMode = config.inlineCompletionTriggerMode;
+      this.chatOutline = config.chatOutline;
     });
     this.updateChatEditResolving();
     window.onDidChangeTextEditorSelection((params) => {
@@ -67,6 +71,15 @@ export class ContextVariables {
     this.chatEditInProgressValue = value;
   }
 
+  get nlOutlinesGenerationInProgress(): boolean {
+    return this.nlOutlinesGenerationInProgressValue;
+  }
+
+  set nlOutlinesGenerationInProgress(value: boolean) {
+    commands.executeCommand("setContext", "tabby.nlOutlinesGenerationInProgress", value);
+    this.nlOutlinesGenerationInProgressValue = value;
+  }
+
   get chatEditResolving(): boolean {
     return this.chatEditResolvingValue;
   }
@@ -84,4 +97,13 @@ export class ContextVariables {
     commands.executeCommand("setContext", "tabby.inlineCompletionTriggerMode", value);
     this.inlineCompletionTriggerModeValue = value;
   }
+
+  get chatOutline(): boolean {
+    return this.chatOutlineValue;
+  }
+
+  set chatOutline(value: boolean) {
+    commands.executeCommand("setContext", "tabby.chat.outline", value);
+    this.chatOutlineValue = value;
+  }
 }

clients/vscode/src/extension.ts

@@ -1,4 +1,4 @@
-import { window, ExtensionContext, Uri } from "vscode";
+import { window, ExtensionContext, Uri, languages } from "vscode";
 import { LanguageClientOptions } from "vscode-languageclient";
 import { LanguageClient as NodeLanguageClient, ServerOptions, TransportKind } from "vscode-languageclient/node";
 import { LanguageClient as BrowserLanguageClient } from "vscode-languageclient/browser";
@@ -13,6 +13,7 @@ import { StatusBarItem } from "./StatusBarItem";
 import { ChatViewProvider } from "./chat/ChatViewProvider";
 import { Commands } from "./Commands";
 import { Status } from "tabby-agent";
+import { NLOutlinesProvider } from "./outline/NLOutlinesProvider";
 import { CodeActionProvider } from "./CodeAction";
 
 const isBrowser = !!process.env["IS_BROWSER"];
@@ -54,6 +55,7 @@ export async function activate(context: ExtensionContext) {
   const contextVariables = new ContextVariables(client, config);
   const inlineCompletionProvider = new InlineCompletionProvider(client, config);
   const gitProvider = new GitProvider();
+
   client.registerConfigManager(config);
   client.registerInlineCompletionProvider(inlineCompletionProvider);
   client.registerGitProvider(gitProvider);
@@ -78,6 +80,9 @@ export async function activate(context: ExtensionContext) {
     }
   });
 
+  const nlOutlinesProvider = new NLOutlinesProvider(config);
+  context.subscriptions.push(languages.registerCodeLensProvider({ scheme: "file" }, nlOutlinesProvider));
+
   // Register chat panel
   const chatViewProvider = new ChatViewProvider(context, client.agent, logger, gitProvider);
   context.subscriptions.push(
@@ -104,6 +109,7 @@ export async function activate(context: ExtensionContext) {
     inlineCompletionProvider,
     chatViewProvider,
     gitProvider,
+    nlOutlinesProvider,
   );
 
   logger.info("Tabby extension activated.");

clients/vscode/src/index.d.ts

@@ -0,0 +1,8 @@
+declare module "*.md" {
+  const content: string;
+  export default content;
+}
+declare module "*.txt" {
+  const content: string;
+  export default content;
+}