refactor: commands

agent/src/agent.ts

@@ -630,7 +630,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

@@ -495,23 +495,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
             )
@@ -529,60 +533,56 @@ 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
+              " Okay, based on the shared context, it looks like Vitest is being used as the test framework. No mocks are detected.
 
-              No additional packages or imports are needed.
-
-              I will focus on testing the Animal interface by validating:
-
-              - The name property is a string
-              - makeAnimalSound returns a string
-              - isMammal is a boolean
+              Here are some new unit tests for the Animal interface in src/animal.ts using Vitest:
 
               \`\`\`ts
-              import { expect } from 'vitest'
-              import { describe, it } from 'vitest'
-              import { Animal } from './animal'
+              import {describe, expect, it} from 'vitest'
+              import {Animal} from './animal'
 
               describe('Animal', () => {
 
-                it('has a name property that is a string', () => {
+                it('has a name property', () => {
                   const animal: Animal = {
-                    name: 'Lion',
-                    makeAnimalSound: () => '',
+                    name: 'Leo',
+                    makeAnimalSound() {
+                      return 'Roar'
+                    },
                     isMammal: true
                   }
 
-                  expect(typeof animal.name).toBe('string')
+                  expect(animal.name).toBe('Leo')
                 })
 
-                it('makeAnimalSound returns a string', () => {
+                it('has a makeAnimalSound method', () => {
                   const animal: Animal = {
-                    name: 'Lion',
-                    makeAnimalSound: () => 'Roar!',
+                    name: 'Whale',
+                    makeAnimalSound() {
+                      return 'Whistle'
+                    },
                     isMammal: true
                   }
 
-                  expect(typeof animal.makeAnimalSound()).toBe('string')
+                  expect(animal.makeAnimalSound()).toBe('Whistle')
                 })
 
-                it('isMammal is a boolean', () => {
+                it('has an isMammal property', () => {
                   const animal: Animal = {
-                    name: 'Lion',
-                    makeAnimalSound: () => '',
-                    isMammal: true
+                    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
                 )
@@ -599,7 +599,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 {
@@ -609,60 +609,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
             )
@@ -702,10 +690,7 @@ describe('Agent', () => {
             check('commands/document (basic function)', 'sum.ts', obtained =>
                 expect(obtained).toMatchInlineSnapshot(`
                   "/**
-                   * Sums two numbers.
-                   * @param a - The first number to sum.
-                   * @param b - The second number to sum.
-                   * @returns The sum of a and b.
+                   * Returns the sum of two numbers.
                    */
                   export function sum(a: number, b: number): number {
                       /* CURSOR */
@@ -722,8 +707,7 @@ describe('Agent', () => {
                       constructor(private shouldGreet: boolean) {}
 
                       /**
-                       * Prints "Hello World!" to the console if this.shouldGreet is true.
-                       * This allows conditionally greeting the user.
+                       * Logs a greeting if the shouldGreet property is true.
                        */
                       public functionName() {
                           if (this.shouldGreet) {
@@ -739,8 +723,7 @@ describe('Agent', () => {
                 expect(obtained).toMatchInlineSnapshot(`
                   "const foo = 42
                   /**
-                   * TestLogger object that contains a startLogging method to initialize logging.
-                   * startLogging sets up a recordLog function that writes log messages to the console.
+                   * Starts logging by initializing and calling the \`recordLog\` function.
                    */
                   export const TestLogger = {
                       startLogging: () => {
@@ -764,12 +747,12 @@ describe('Agent', () => {
                   import { describe } from 'vitest'
 
                   /**
-                   * Test block that runs a set of test cases.
+                   * A test block with multiple test cases.
                    *
                    * Contains 3 test cases:
-                   * - 'does 1' checks an expectation
-                   * - 'does 2' checks an expectation
-                   * - 'does something else' has a commented out line that errors
+                   * - 'does 1' asserts that true equals true
+                   * - 'does 2' asserts that true equals true
+                   * - 'does something else' has a commented out line that would error due to incorrect usage of \`performance.now\`
                    */
                   describe('test block', () => {
                       it('does 1', () => {

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,