feat: support for more target keyword

Author: Barbapapazes

package.json

@@ -98,10 +98,12 @@
               "target": {
                 "type": "string",
                 "enum": [
-                  "inplace",
+                  "replace",
+                  "append",
+                  "prepend",
                   "newfile"
                 ],
-                "default": "inplace",
+                "default": "replace",
                 "description": "Where to put the result of the action"
               },
               "git": {

src/ai/base_ai.ts

@@ -1,12 +1,12 @@
-import type { Awaitable } from '../types/index.js'
+import type { Awaitable, BaseAIConfiguration } from '../types/index.js'
 
-export class BaseAI {
+export class BaseAI<T extends BaseAIConfiguration = BaseAIConfiguration> {
   static name: string
 
   protected key: string
-  protected options: Record<string, unknown>
+  protected options: T
 
-  constructor(key: string, options: Record<string, unknown> = {}) {
+  constructor(key: string, options: T) {
     this.key = key
     this.options = options
   }

src/ai/index.ts

@@ -1,6 +1,7 @@
+import type { BaseAIConfiguration } from '../types/index.js'
 import type { BaseAI } from './base_ai.js'
 import { OpenAI } from './openai.js'
 
-export const ai: Record<string, typeof BaseAI> = {
+export const ai: Record<string, typeof BaseAI<BaseAIConfiguration>> = {
   openai: OpenAI,
 }

src/ai/openai.ts

@@ -1,21 +1,22 @@
+import type { OpenAIConfiguration } from '../types/index.js'
 import { BaseAI } from './base_ai.js'
 
-export class OpenAI extends BaseAI {
+export class OpenAI extends BaseAI<OpenAIConfiguration> {
   static name = 'OpenAI'
 
-  constructor(key: string, options: Record<string, unknown> = {}) {
-    super(key, options)
-  }
+  protected endpoint = 'https://api.openai.com/v1/chat/completions'
 
   async ask(prompt: string, content: string): Promise<string> {
-    return await fetch('https://api.openai.com/v1/chat/completions', {
+    const { endpoint = this.endpoint, model } = this.options
+
+    return await fetch(endpoint, {
       method: 'POST',
       headers: {
         'Content-Type': 'application/json',
         'Authorization': `Bearer ${this.key}`,
       },
       body: JSON.stringify({
-        model: this.options.model,
+        model,
         messages: [{ role: 'system', content: prompt }, { role: 'user', content }],
       }),
     })

src/commands/run_action_command.ts

@@ -26,12 +26,12 @@ export class RunActionCommand extends BaseCommand {
       const ai = await this.createAI(configuration)
       const completion = await ai.ask(prompt.content, this.getActiveEditorText())
 
-      if (action.target === 'inplace') {
-        await this.applyChanges(completion)
-      }
-      else if (action.target === 'newfile') {
+      if (action.target === 'newfile') {
         await this.showCompletion(completion)
       }
+      else {
+        await this.applyChanges(completion, action.target)
+      }
     })
 
     await this.commitWithAction(action, 'after')
@@ -92,7 +92,7 @@ export class RunActionCommand extends BaseCommand {
   }
 
   protected async createAI(configuration: AI): Promise<BaseAI> {
-    const AI = aiIndex[configuration.type]
+    const AI = aiIndex[configuration.provider]
 
     this.assert(AI, 'AI not found.')
 
@@ -101,7 +101,7 @@ export class RunActionCommand extends BaseCommand {
     this.assert(key, 'Key not found.')
 
     return new AI(key, {
-      model: configuration.model,
+      ...configuration.configuration,
     })
   }
 
@@ -138,14 +138,22 @@ export class RunActionCommand extends BaseCommand {
     await this.getActiveEditor().document.save()
   }
 
-  protected async applyChanges(content: string): Promise<void> {
+  protected async applyChanges(content: string, target: Action['target']): Promise<void> {
     this.logger.log('Apply changes...')
 
     this.getActiveEditor().edit((editBuilder) => {
       const range = this.hasActiveEditorSelection() ? this.getActiveEditorSelection() : new Range(0, 0, this.getActiveEditorText().length, 0)
 
-      editBuilder.delete(range)
-      editBuilder.insert(range.start, content)
+      if (target === 'replace') {
+        editBuilder.delete(range)
+      }
+
+      if (target === 'append') {
+        editBuilder.insert(range.end, `\n${content}`)
+      }
+      else if (target === 'replace' || target === 'prepend') {
+        editBuilder.insert(range.start, `${content}\n`)
+      }
     })
 
     await this.saveActiveEditor()
@@ -159,8 +167,6 @@ export class RunActionCommand extends BaseCommand {
   }
 
   protected async commitWithAction(action: Action, when: 'before' | 'after'): Promise<void> {
-    this.logger.log(`Commit changes ${when} action...`)
-
     let commitMessage = when === 'before' ? action.git?.commitMessageBeforeAction : action.git?.commitMessageAfterAction
 
     if (!commitMessage) {
@@ -173,6 +179,7 @@ export class RunActionCommand extends BaseCommand {
 
     this.assert(commitMessage, 'Commit message is required.')
 
+    this.logger.log(`Commit changes ${when} action...`)
     await this.commit(this.getActiveEditor().document.fileName, commitMessage)
   }
 

src/types/index.ts

@@ -1,5 +1,12 @@
 export type Awaitable<T> = T | Promise<T>
 
+export type BaseAIConfiguration = Record<string, any>
+
+export interface OpenAIConfiguration {
+  model: string
+  endpoint?: string
+}
+
 export interface Prompt {
   name: string
   content: string
@@ -8,15 +15,15 @@ export interface Prompt {
 export interface AI {
   name: string
   keyName: string
-  type: string
-  model: string
+  provider: 'openai'
+  configuration: OpenAIConfiguration
 }
 
 export interface Action {
   name: string
   ai: AI['name']
   prompt: Prompt['name']
-  target: 'inplace' | 'newfile'
+  target: 'replace' | 'append' | 'prepend' | 'newfile'
   git?: {
     commitMessageBeforeAction?: '__ask__' | (string & {})
     commitMessageAfterAction?: '__ask__' | (string & {})