Enhance VSCode extension with inline editing capabilities and LLM integration; refactor code structure and improve configuration handling

Author: doofin

build.sbt

@@ -22,7 +22,8 @@ lazy val root = project
     scalaVersion := "3.3.4",
     // warn unused imports and vars
     scalacOptions ++= Seq(
-      "-Wunused:all"
+      "-Wunused:all",
+      "-no-indent"
     ),
     // check if it is running in test
     // testOptions += Tests.Setup(_ => sys.props("testing") = "true"),
@@ -80,8 +81,10 @@ def openVSCodeTask(openVscode: Boolean = true): Def.Initialize[Task[Unit]] =
       }
       // launch vscode
       if (openVscode) {
+        val extenPath = s"${path}/${outdir}"
         println("\u001b[33m" + "[opening] vscode" + "\u001b[0m")
-        s"code --extensionDevelopmentPath=$path" ! log
+        println("\u001b[33m" + s"with extensionDevelopmentPath=${extenPath}" + "\u001b[0m")
+        s"code --extensionDevelopmentPath=$extenPath" ! log
       }
       ()
     }

src/main/scala/functorcoder/actions/Commands.scala

@@ -1,26 +1,43 @@
 package functorcoder.actions
+import scala.concurrent.ExecutionContext.Implicits.global
 
 import typings.vscode.mod as vscode
 
 import scala.collection.immutable
 import scala.scalajs.js
 
 import vscextension.quickPick
+import vscextension.facade.vscodeUtils.showMessageAndLog
+import scala.concurrent.Future
+import functorcoder.types.editorCtx.codeActionParam
 
 /** Commands are actions that a user can invoke in the vscode extension with command palette (ctrl+shift+p).
   */
 object Commands {
   type CommandT = Any => Unit
   // all the commands here
   val commandMenu = "functorcoder.menu"
+  val commandAddDocumentation = "functorcoder.addDocumentation"
 
   val commandList: Seq[(String, CommandT)] =
     Seq(
-      (commandMenu, quickPick.showQuickPick)
+      (commandMenu, quickPick.showQuickPick),
+      (commandAddDocumentation, addDocumentation)
     )
 
     // the main menu items
   val mainMenuItems: Seq[(String, () => Unit)] = Seq(
     "create files" -> { () => println("create files") }
   )
+
+  def addDocumentation(arg: Any) = {
+    val param =
+      arg.asInstanceOf[codeActionParam[Future[String]]]
+    val llmResponse = param.param
+    llmResponse.foreach { response =>
+      showMessageAndLog("add doc: " + s"${param.documentUri}, ${param.range}, ${response}")
+    }
+
+    // showMessageAndLog("add documentation: " + s"${dyn.uri}, ${dyn.range}, ${dyn.llmResponse}")
+  }
 }

src/main/scala/functorcoder/editorUI/diffEdit.scala

@@ -1,10 +1,14 @@
 package functorcoder.editorUI
 
+import scala.concurrent.ExecutionContext.Implicits.global
+
+import functorcoder.llm.llmMain
+import functorcoder.llm.llmPrompt
+
 /** This abstract the editor behavior for inline editing
   *
-  * Scenario: A new version of the file is shown to the user in the editor with the changes highlighted,
-  *
-  * and the user can choose to accept or reject the changes.
+  * Scenario: user wants to edit a selected snippet of code in the editor, the coding assistant will provide a modified
+  * version of the snippet with the changes highlighted, and the user can choose to accept or reject the changes.
   */
 object diffEdit {
 
@@ -13,6 +17,12 @@ object diffEdit {
       character: Int
   )
 
+  case class DiffRequest(
+      oldText: String,
+      cursorPosition: CursorPosition,
+      task: String // the task to perform
+  )
+
   /** The result of the diff operation
     *
     * @param oldText
@@ -27,7 +37,33 @@ object diffEdit {
   case class DiffResult(
       oldText: String,
       newText: String,
-      cursorPosition: CursorPosition,
-      difference: Seq[String]
+      cursorPosition: CursorPosition
+      // difference: Seq[String]
   )
+
+  /** action to modify the code, like adding new code
+    *
+    * @param llmAgent
+    *   the agent to perform the diff operation
+    * @param diffReq
+    *   the diff request
+    * @return
+    *   the result of the diff operation
+    */
+  def diff(llmAgent: llmMain.llmAgent, diffReq: DiffRequest) = {
+    val prompt = llmPrompt.Modification(
+      code = diffReq.oldText,
+      taskRequirement = ""
+    )
+
+    val llmResponse = llmAgent.sendPrompt(prompt)
+
+    llmResponse.map(txt =>
+      DiffResult(
+        oldText = diffReq.oldText,
+        newText = txt,
+        cursorPosition = diffReq.cursorPosition
+      )
+    )
+  }
 }

src/main/scala/functorcoder/llm/llmMain.scala

@@ -12,6 +12,7 @@ import scala.scalajs.js.Thenable.Implicits.*
 import scala.concurrent.Future
 
 import functorcoder.editorUI.editorConfig
+import cats.syntax.show
 
 /** large language model (LLM) AI main
   *
@@ -27,16 +28,21 @@ object llmMain {
     *   completion prompt object
     * @return
     */
-  def getCompletionPrompt(completionPrompt: llmPrompt.Completion) = {
-    openaiReq
+  def prompt2str(inputPrompt: llmPrompt.Prompt) = {
+    showMessageAndLog(s"prompt: ${inputPrompt}")
+    showMessageAndLog(s"prompt assistant: ${inputPrompt.getAssistantMessage}")
+
+    val openAiRequest = openaiReq
       .OpenAiRequest(
         List(
-          openaiReq.Message(roles.user, completionPrompt.codeWithHole),
-          openaiReq.Message(roles.system, completionPrompt.assistantMessage)
+          openaiReq.Message(roles.user, inputPrompt.generatePrompt),
+          openaiReq.Message(roles.system, inputPrompt.getAssistantMessage)
         ),
         openaiReq.models.gpt4o
       )
-      .toJson
+
+    showMessageAndLog(s"openai request: ${openAiRequest}")
+    openAiRequest.toJson
   }
 
   case class llmAgent(editorCfg: editorConfig.Config) {
@@ -51,10 +57,10 @@ object llmMain {
       *
       * so we will call this function with the hole "{{FILL_HERE}}" you insert it in the code
       */
-    def getCodeCompletion(holeToCode: String => String) = {
-      val requestStr = getCompletionPrompt(
-        llmPrompt
-          .Completion(holeToCode("{{FILL_HERE}}"))
+    def sendPrompt(input: llmPrompt.Prompt) = {
+
+      val requestStr = prompt2str(
+        input
       )
 
       val requestOptions = getRequestOptions(requestStr)
@@ -76,6 +82,15 @@ object llmMain {
       }
     }
 
+    /** get the response text from ai api, only the content of the first choice
+      *
+      * it parses the response json and returns the first choice
+      *
+      * @param responseFuture
+      *   the response future
+      * @return
+      *   the response text
+      */
     private def getResponseText(responseFuture: Future[nodeFetch.Response]) = {
       for {
         res <- responseFuture

src/main/scala/functorcoder/llm/llmPrompt.scala

@@ -5,8 +5,13 @@ package functorcoder.llm
   * for completion, code generation, etc.
   */
 object llmPrompt {
+  // trait will have undefined value
+  sealed abstract class Prompt(val assistantMsg: String) {
+    def generatePrompt: String
+    def getAssistantMessage: String = assistantMsg
+  }
 
-  /** a configuration for code completion
+  /** code completion prompt
     *
     * https://github.com/continuedev/continue/blob/main/core/autocomplete/templating/AutocompleteTemplate.ts
     *
@@ -26,8 +31,8 @@ object llmPrompt {
   case class Completion(
       codeWithHole: String, // code with a hole to fill like {{FILL_HERE}}
       // taskRequirement: String, // like "Fill the {{FILL_HERE}} hole."
-      assistantMessage: String = prompts.prompt1
-  ) {
+      assistantMessage: String = promptText.prompt1
+  ) extends Prompt(assistantMessage) {
     def generatePrompt = {
       // shall return a string wrapped with <COMPLETION></COMPLETION>
       // s"""<QUERY>
@@ -40,13 +45,38 @@ object llmPrompt {
        */
       codeWithHole
     }
+
+  }
+
+  /** modify code snippet
+    *
+    * @param code
+    *   code snippet
+    * @param taskRequirement
+    *   like "Fill the {{FILL_HERE}} hole."
+    * @param assistantMessage
+    *   like "always give scala code examples."
+    */
+  case class Modification(
+      code: String,
+      taskRequirement: String,
+      assistantMessage: String = promptText.promptTask
+  ) extends Prompt(assistantMessage) {
+    def generatePrompt = {
+      s"""<QUERY>
+    |${code}
+    |</QUERY>
+    |TASK: ${taskRequirement}
+    |""".stripMargin
+    }
   }
 
   /** prompts engineering
     *
     * more like art than science. just try different prompts and see what works best
     */
-  object prompts {
+  object promptText {
+    val hole = "{{FILL_HERE}}"
     val prompt1 =
       "You are a code or text autocompletion assistant. " +
         "In the provided input, missing code or text are marked as '{{FILL_HERE}}'. " +
@@ -58,11 +88,15 @@ object llmPrompt {
         "{{FILL_HERE}}  in the string, " +
         "your task is to replace this hole with your reply." +
         "you only return the string for the hole with indentation, without any quotes"
+
+    val promptTask =
+      "You are given a text or code snippet wrapped in a <QUERY> tag and a TASK requirement. " +
+        "You are going to return the new snippet according to the TASK requirement. "
   }
 }
 
 /* example:
-    <QUERY>
+<QUERY>
 function sum_evens(lim) {
   var sum = 0;
   for (var i = 0; i < lim; ++i) {

src/main/scala/functorcoder/llm/wk.worksheet.sc

@@ -0,0 +1,20 @@
+import functorcoder.llm.llmPrompt
+import functorcoder.llm.llmPrompt.Prompt
+import fansi.Str
+val Modification = llmPrompt
+  .Modification(code = "val x = 1", taskRequirement = "add documentation")
+
+Modification.asInstanceOf[Prompt]
+
+sealed trait trait1(val param1: String) {
+  // def method1: String = param1
+}
+
+case class class1(override val param1: String = "s1") extends trait1(param1)
+
+val c1 = class1()
+
+def m1(t1: trait1) = {
+  println(s"t1 param1: ${t1.param1}")
+}
+// c1.method1

src/main/scala/functorcoder/types/editorCtx.scala

@@ -1,4 +1,5 @@
 package functorcoder.types
+import scala.scalajs.js
 
 object editorCtx {
 
@@ -10,4 +11,10 @@ object editorCtx {
   case class EditorContext(
       language: String
   )
+
+  class codeActionParam[T](
+      val documentUri: String, //
+      val range: typings.vscode.mod.Selection,
+      val param: T
+  ) extends js.Object
 }