refactor: commands

agent/src/agent.ts

@@ -618,7 +618,7 @@ export class Agent extends MessageHandler {
         })
 
         // The arguments to pass to the command to make sure edit commands would also run in chat mode
-        const commandArgs = [{ runInChatMode: true, source: 'editor' }]
+        const commandArgs = [{ source: 'editor' }]
 
         this.registerAuthenticatedRequest('commands/explain', () => {
             return this.createChatPanel(

agent/src/index.test.ts

@@ -929,23 +929,27 @@ describe('Agent', () => {
             const lastMessage = await client.firstNonEmptyTranscript(id)
             expect(trimEndOfLine(lastMessage.messages.at(-1)?.text ?? '')).toMatchInlineSnapshot(
                 `
-              " The Animal interface:
+              " Here is an explanation of the selected TypeScript code in simple terms:
 
-              The Animal interface defines the shape of objects that represent animals. Interfaces in TypeScript are used to define the structure of an object - what properties and methods it should have.
+              The Animal interface
 
-              This interface has three properties:
+              The Animal interface defines the shape of an Animal object. It does not contain any actual implementation, just declarations for what properties and methods an Animal object should have.
 
-              1. name - This will be a string property to represent the animal's name.
+              The interface has three members:
 
-              2. makeAnimalSound() - This is a method that will be implemented by classes that implement the Animal interface. It allows each animal to have its own implementation of making a sound.
+              1. name - This is a string property to store the animal's name.
 
-              3. isMammal - This is a boolean property that will specify if the animal is a mammal or not.
+              2. makeAnimalSound() - This is a method that should return a string representing the sound the animal makes.
 
-              The interface does not contain any actual implementation, just the definition of what properties and methods any class implementing Animal should have. This allows us to define a consistent structure that can be reused across different animal classes.
+              3. isMammal - This is a boolean property that indicates if the animal is a mammal or not.
 
-              By defining an Animal interface, we can then create multiple classes like Dog, Cat, Bird etc that implement the interface and provide their own specific logic while ensuring they match the general Animal structure.
+              The purpose of this interface is to define a consistent structure for Animal objects. Any class that implements the Animal interface will be required to have these three members with these types.
 
-              Interfaces are a powerful way to define contracts in TypeScript code and allow different implementations to guarantee they can work together smoothly. This Animal interface creates a reusable way to model animals in a type-safe way."
+              This allows code dealing with Animal objects to know it can call animal.makeAnimalSound() and access animal.name and animal.isMammal, regardless of the specific class. The interface defines the contract between the implementation and usage of Animals, without caring about specific details.
+
+              Interfaces like this are useful for writing reusable code that can handle different types of objects in a consistent way. The code using the interface doesn't need to know about the specifics of each class, just that it implements the Animal interface. This allows easily extending the code to handle new types of animals by simply creating a new class implementing Animal.
+
+              So in summary, the Animal interface defines the input expectations and output guarantees for objects representing animals in the system, allowing code to work with any animal in a generic way based on this contract."
             `,
                 explainPollyError
             )
@@ -961,61 +965,57 @@ describe('Agent', () => {
                 const lastMessage = await client.firstNonEmptyTranscript(id)
                 expect(trimEndOfLine(lastMessage.messages.at(-1)?.text ?? '')).toMatchInlineSnapshot(
                     `
-              " Okay, based on the shared context, it looks like:
-
-              - The test framework in use is Vitest
-              - The assertion library is vitest's built-in expect
-
-              No additional packages or imports are needed.
+                  " Okay, based on the shared context, it looks like Vitest is being used as the test framework. No mocks are detected.
 
-              I will focus on testing the Animal interface by validating:
+                  Here are some new unit tests for the Animal interface in src/animal.ts using Vitest:
 
-              - The name property is a string
-              - makeAnimalSound returns a string
-              - isMammal is a boolean
+                  \`\`\`ts
+                  import {describe, expect, it} from 'vitest'
+                  import {Animal} from './animal'
 
-              \`\`\`ts
-              import { expect } from 'vitest'
-              import { describe, it } from 'vitest'
-              import { Animal } from './animal'
+                  describe('Animal', () => {
 
-              describe('Animal', () => {
-
-                it('has a name property that is a string', () => {
-                  const animal: Animal = {
-                    name: 'Lion',
-                    makeAnimalSound: () => '',
-                    isMammal: true
-                  }
+                    it('has a name property', () => {
+                      const animal: Animal = {
+                        name: 'Leo',
+                        makeAnimalSound() {
+                          return 'Roar'
+                        },
+                        isMammal: true
+                      }
 
-                  expect(typeof animal.name).toBe('string')
-                })
+                      expect(animal.name).toBe('Leo')
+                    })
 
-                it('makeAnimalSound returns a string', () => {
-                  const animal: Animal = {
-                    name: 'Lion',
-                    makeAnimalSound: () => 'Roar!',
-                    isMammal: true
-                  }
+                    it('has a makeAnimalSound method', () => {
+                      const animal: Animal = {
+                        name: 'Whale',
+                        makeAnimalSound() {
+                          return 'Whistle'
+                        },
+                        isMammal: true
+                      }
 
-                  expect(typeof animal.makeAnimalSound()).toBe('string')
-                })
+                      expect(animal.makeAnimalSound()).toBe('Whistle')
+                   }
 
-                it('isMammal is a boolean', () => {
-                  const animal: Animal = {
-                    name: 'Lion',
-                    makeAnimalSound: () => '',
-                    isMammal: true
-                  }
+                    it('has an isMammal property', () => {
+                      const animal: Animal = {
+                        name: 'Snake',
+                        makeAnimalSound() {
+                          return 'Hiss'
+                        },
+                        isMammal: false
+                      }
 
-                  expect(typeof animal.isMammal).toBe('boolean')
-                })
+                      expect(animal.isMammal).toBe(false)
+                    })
 
-              })
-              \`\`\`
+                  })
+                  \`\`\`
 
-              This covers basic validation of the Animal interface's properties and methods. Let me know if you'd like me to expand the tests further."
-            `,
+                  This covers basic validation of the Animal interface properties and methods using Vitest assertions. Additional test cases could be added for more edge cases."
+                `,
                     explainPollyError
                 )
             },
@@ -1031,7 +1031,7 @@ describe('Agent', () => {
                 `
               " Here are 5 potential improvements for the selected TypeScript code:
 
-              1. Add type annotations for method parameters and return types:
+              1. Add type annotations for method parameters and return values:
 
               \`\`\`
               export interface Animal {
@@ -1041,60 +1041,48 @@ describe('Agent', () => {
               }
               \`\`\`
 
-              Adding explicit types for methods makes the interface clearer and allows TypeScript to catch more errors at compile time.
+              Adding type annotations makes the code more self-documenting and enables stronger type checking.
 
-              2. Make name readonly:
+              2. Make interface name more semantic:
 
               \`\`\`
-              export interface Animal {
-                readonly name: string
+              export interface Creature {
                 // ...
               }
               \`\`\`
 
-              This prevents the name from being reassigned after initialization, making the code more robust.
+              The name 'Animal' is not very descriptive. A name like 'Creature' captures the intent better.
 
-              3. Add alternate method name:
+              3. Make sound method name more semantic:
 
               \`\`\`
-              export interface Animal {
-
-                // ...
-
-                getSound(): string
-              }
+              makeSound()
               \`\`\`
 
-              Adding a method like \`getSound()\` as an alias for \`makeAnimalSound()\` improves readability.
+              The name 'makeAnimalSound' is verbose. A shorter name like 'makeSound' conveys the purpose clearly.
 
-              4. Use boolean getter instead of property for isMammal:
+              4. Use boolean type for isMammal property:
 
               \`\`\`
-              export interface Animal {
-
-                // ...
-
-                get isMammal(): boolean
-              }
+              isMammal: boolean
               \`\`\`
 
-              This allows encapsulation of the logic for determining if mammal.
+              Using the boolean type instead of just true/false improves readability.
 
-              5. Extend a base interface like LivingThing:
+              5. Add JSDoc comments for documentation:
 
               \`\`\`
-              interface LivingThing {
-                name: string
-              }
-
-              interface Animal extends LivingThing {
+              /**
+               * Represents a creature in the game
+               */
+              export interface Creature {
                 // ...
               }
               \`\`\`
 
-              This improves maintainability by separating common properties into a base interface.
+              JSDoc comments enable generating API documentation and improve understandability.
 
-              Overall, the code is well-written but could benefit from some minor changes like adding types, encapsulation, and semantic method names. The interface follows sound principles like read-only properties andboolean getters. No major issues were found."
+              Overall, the selected code follows reasonable design principles. The interface encapsulates animal data nicely. The suggestions above would incrementally improve quality but no major issues were found."
             `,
                 explainPollyError
             )

lib/shared/src/chat/transcript/messages.ts

@@ -1,8 +1,8 @@
 import type { ContextFile, PreciseContext } from '../../codebase-context/messages'
-import type { CodyDefaultCommands } from '../../commands'
 import type { Message } from '../../sourcegraph-api'
 
 import type { TranscriptJSON } from '.'
+import type { DefaultCodyCommands } from '../../commands/types'
 
 export interface ChatButton {
     label: string
@@ -68,7 +68,7 @@ export type ChatEventSource =
     | 'custom-commands'
     | 'test'
     | 'code-lens'
-    | CodyDefaultCommands
+    | DefaultCodyCommands
 
 /**
  * Converts an Error to a ChatError. Note that this cannot be done naively,

lib/shared/src/commands/types.ts

@@ -0,0 +1,69 @@
+// The default Cody Commands
+export type DefaultCodyCommands = DefaultChatCommands | DefaultEditCommands
+
+// Default Cody Commands that runs as a Chat request
+export enum DefaultChatCommands {
+    Ask = 'chat', // Submit a question in chat
+    Explain = 'explain', // Explain code
+    Test = 'test', // Generate unit tests in Chat
+    Smell = 'smell', // Generate code smell report in Chat
+}
+
+// Default Cody Commands that runs as an Inline Edit command
+export enum DefaultEditCommands {
+    Edit = 'edit', // Inline edit request
+    Unit = 'unit', // Generate unit tests with inline edit
+    Doc = 'doc', // Generate documentation with inline edit
+}
+
+// The blueprint of a Cody Custom Command
+export interface CodyCommand {
+    slashCommand: string
+    prompt: string
+    description?: string
+    context?: CodyCommandContext
+    type?: CodyCommandType
+    mode?: CodyCommandMode
+
+    // Internal use - the ID of the request
+    requestID?: string
+}
+
+/**
+ * - 'ask' mode is the default mode, run prompt in chat view
+ * - 'edit' mode will run prompt with edit command which replace selection with cody's response
+ * - 'insert' mode is the same as edit, it adds to the top of the selection instead of replacing selection
+ * - 'file' mode create a new file with cody's response as content
+ */
+type CodyCommandMode = 'ask' | 'edit' | 'insert' | 'file'
+
+// Type of context available for prompt building
+export interface CodyCommandContext {
+    // Exclude any context.
+    // It takes precedence over all other context.
+    none?: boolean
+
+    // Tabs from the current workspace
+    openTabs?: boolean
+    // The directory with the current file opened in the editor
+    currentDir?: boolean
+    // The current file opened in the editor
+    currentFile?: boolean
+    // The current selection in the editor
+    // Default to use smart selection unless set to false specifically
+    selection?: boolean
+    // Shell command to run to get context
+    command?: string
+    // The relative path of a file within your workspace root
+    filePath?: string
+    // The relative path of a directory within your workspace root
+    directoryPath?: string
+
+    // NOTE: Currently not supported
+    // Codebase context from current codebase
+    codebase?: boolean
+}
+
+export type CodyCommandType = CustomCommandType | 'default' | 'recently used' | 'experimental'
+
+export type CustomCommandType = 'workspace' | 'user'