documentation

10 files changed, 190 insertions, 52 deletions

diff --git a/.gitignore b/.gitignore
index 48f60e7f..8f403dfe 100644
--- a/.gitignore
+++ b/.gitignore
@@ -131,7 +131,7 @@ dmypy.json
 
 **/node_modules
 **/out
-**/.vscode
+**/.vscode/settings.json
 notes.txt
 cached_embeddings.pkl
 .ruff_cache
diff --git a/.vscode/launch.json b/.vscode/launch.json
new file mode 100644
index 00000000..cc7b1ce4
--- /dev/null
+++ b/.vscode/launch.json
@@ -0,0 +1,17 @@
+{
+  // Use IntelliSense to learn about possible attributes.
+  // Hover to view descriptions of existing attributes.
+  // For more information, visit: https://go.microsoft.com/fwlink/?linkid=830387
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Python: Module",
+      "type": "python",
+      "request": "launch",
+      "module": "continuedev.src.continuedev.server.main",
+      "args": ["--port", "8001"],
+      "justMyCode": false,
+      "subProcess": false
+    }
+  ]
+}
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7e49dc2d..f7166411 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -2,56 +2,87 @@
 
 ## Table of Contents
 
-- [Continue Architecture](#continue-architecture)
-- [Core Concepts](#core-concepts)
+- [❤️ Ways to Contribute](#❤️-ways-to-contribute)
+  - [🐛 Report Bugs](#🐛-report-bugs)
+  - [✨ Suggest Enhancements](#✨-suggest-enhancements)
+  - [📖 Updating / Improving Documentation](#📖-updating--improving-documentation)
+  - [🧑‍💻 Contributing Code](#🧑‍💻-contributing-code)
+    - [Setup Development Environment](#setting-up-the-development-environment)
+    - [Writing Steps](#writing-steps)
+    - [Writing Context Providers](#writing-context-providers)
+- [📐 Continue Architecture](#📐-continue-architecture)
+  - [Continue VS Code Client](#continue-vs-code-client)
+  - [Continue IDE Websockets Protocol](#continue-ide-websockets-protocol)
+  - [Continue GUI Websockets Protocol](#continue-gui-websockets-protocol)
+- [❇️ Core Concepts](#❇️-core-concepts)
   - [Step](#step)
-- [Continue VS Code Client](#continue-vs-code-client)
-- [Continue IDE Websockets Protocol](#continue-ide-websockets-protocol)
-- [Continue GUI Websockets Protocol](#continue-gui-websockets-protocol)
-- [Ways to Contribute](#ways-to-contribute)
-  - [Report Bugs](#report-bugs)
-  - [Suggest Enhancements](#suggest-enhancements)
-  - [Updating / Improving Documentation](#updating--improving-documentation)
+  - [Autopilot](#autopilot)
+  - [Observation](#observation)
+  - [Policy](#policy)
 
-## Continue Architecture
+# ❤️ Ways to Contribute
 
-Continue consists of 3 components, designed so that Continue can easily be extended to work in any IDE:
+## 🐛 Report Bugs
 
-1. **Continue Server** - The Continue Server is responsible for keeping state, running the autopilot loop which takes actions, and communicating between the IDE and GUI.
+If you find a bug, please [create an issue](https://github.com/continuedev/continue/issues) to report it! A great bug report includes:
 
-2. **Continue IDE Client** - The Continue IDE Client is a plugin for the IDE which implements the Continue IDE Protocol. This allows the server to request actions to be taken within the IDE, for example if `sdk.ide.setFileOpen("main.py")` is called on the server, it will communicate over websocketes with the IDE, which will open the file `main.py`. The first IDE Client we have built is for VS Code, but we plan to build clients for other IDEs in the future. The IDE Client must 1. implement the websockets protocol, as is done [here](./extension/src/continueIdeClient.ts) for VS Code and 2. launch the Continue Server, like [here](./extension/src/activation/environmentSetup.ts), and 3. display the Continue GUI in a sidebar, like [here](./extension/src/debugPanel.ts).
+- A description of the bug
+- Steps to reproduce
+- What you expected to happen
+- What actually happened
+- Screenshots or videos
 
-3. **Continue GUI** - The Continue GUI is a React application that gives the user control over Continue. It displays the history of Steps, shows what context is included in the current Step, and lets the users enter natural language or slash commands to initiate new Steps. The GUI communicates with the Continue Server over its own websocket connection
+## ✨ Suggest Enhancements
 
-It is important that the IDE Client and GUI never communicate except when the IDE Client initially sets up the GUI. This ensures that the server is the source-of-truth for state, and that we can easily extend Continue to work in other IDEs.
+Continue is quickly adding features, and we'd love to hear which are the most important to you. The best ways to suggest an enhancement are
 
-![Continue Architecture](https://continue.dev/docs/assets/images/continue-architecture-146a90742e25f6524452c74fe44fa2a0.png)
+- Create an issue
 
-## Core Concepts
+  - First, check whether a similar proposal has already been made
+  - If not, [create an issue](https://github.com/continuedev/continue/issues)
+  - Please describe the enhancement in as much detail as you can, and why it would be useful
 
-All of Continue's logic happens inside of the server, and it is built around a few core concepts. Most of these are Pydantic Models defined in [core/main.py](./continuedev/src/continuedev/core/main.py).
+- Join the [Continue Discord](https://discord.gg/NWtdYexhMs) and tell us about your idea in the `#feedback` channel
 
-### `Step`
+## 📖 Updating / Improving Documentation
 
-Everything in Continue is a "Step". The `Step` class defines 2 methods:
+Continue is continuously improving, but a feature isn't complete until it is reflected in the documentation! If you see something out-of-date or missing, you can help by clicking "Edit this page" at the bottom of any page on [continue.dev/docs](https://continue.dev/docs).
 
-1. `async def run(self, sdk: ContinueSDK) -> Coroutine[Observation, None, None]` - This method defines what happens when the Step is run. It has access to the Continue SDK, which lets you take actions in the IDE, call LLMs, run nested Steps, and more. Optionally, a Step can return an `Observation` object, which a `Policy` can use to make decisions about what to do next.
+## 🧑‍💻 Contributing Code
 
-2. `async def describe(self, models: Models) -> Coroutine[str, None, None]` - After each Step is run, this method is called to asynchronously generate a summary title for the step. A `Models` object is passed so that you have access to LLMs to summarize for you.
+### Setting up the Development Environment
 
-Steps are designed to be composable, so that you can easily build new Steps by combining existing ones. And because they are Pydantic models, they can instantly be used as tools useable by an LLM, for example with OpenAI's function-calling functionality (see [ChatWithFunctions](./continuedev/src/continuedev/steps/chat.py) for an example of this).
+There are different levels of setup necessary depending on which part of Continue you are developing. For all of them, first clone the repo:
 
-Some of the most commonly used Steps are:
+```bash
+git clone https://github.com/continuedev/continue
+```
 
-- [`SimpleChatStep`](./continuedev/src/continuedev/steps/chat.py) - This is the default Step that is run when the user enters natural language input. It takes the user's input and runs it through the default LLM, then displays the result in the GUI.
+If editing only the server (`/continuedev` directory), see the directions in [continuedev/README.md](./continuedev/README.md) to set up the Python server. Once it is running on localhost:8001, you can connect your existing VS Code extension by going to VS Code settings, searching for "Continue: Server URL", and setting it to "http://localhost:8001".
 
-- [`EditHighlightedCodeStep`](./continuedev/src/continuedev/steps/core/core.py) - This is the Step run when a user highlights code, enters natural language, and presses CMD/CTRL+ENTER, or uses the slash command '/edit'. It opens a side-by-side diff editor, where updated code is streamed to fulfil the user's request.
+If editing the VS Code extension (`/extension` directory) or GUI (`/extension/react-app`), you can follow the instructions in [`extension/DEV_README.md`](./extension/DEV_README.md) to set up the VS Code extension and GUI in development mode.
 
-### `Autopilot`
+### Writing Steps
 
-### `Observation`
+A Step can be used as a custom slash command, or called otherwise in a `Policy`. See the [steps README](./continuedev/src/continuedev/steps/README.md) to learn how to write a Step.
 
-### `Policy`
+### Writing Context Providers
+
+A `ContextProvider` is a Continue plugin that lets type '@' to quickly select documents as context for the language model. The simplest way to create a `ContextProvider` is to implement the `provide_context_items` method. You can find a great example of this in [GitHubIssuesContextProvider](./continuedev/src/continuedev/libs/context_providers/github_issues.py), which allows you to search GitHub Issues in a repo.
+
+## 📐 Continue Architecture
+
+Continue consists of 3 components, designed so that Continue can easily be extended to work in any IDE:
+
+1. **Continue Server** - The Continue Server is responsible for keeping state, running the autopilot loop which takes actions, and communicating between the IDE and GUI.
+
+2. **Continue IDE Client** - The Continue IDE Client is a plugin for the IDE which implements the Continue IDE Protocol. This allows the server to request actions to be taken within the IDE, for example if `sdk.ide.setFileOpen("main.py")` is called on the server, it will communicate over websocketes with the IDE, which will open the file `main.py`. The first IDE Client we have built is for VS Code, but we plan to build clients for other IDEs in the future. The IDE Client must 1. implement the websockets protocol, as is done [here](./extension/src/continueIdeClient.ts) for VS Code and 2. launch the Continue Server, like [here](./extension/src/activation/environmentSetup.ts), and 3. display the Continue GUI in a sidebar, like [here](./extension/src/debugPanel.ts).
+
+3. **Continue GUI** - The Continue GUI is a React application that gives the user control over Continue. It displays the history of Steps, shows what context is included in the current Step, and lets the users enter natural language or slash commands to initiate new Steps. The GUI communicates with the Continue Server over its own websocket connection
+
+It is important that the IDE Client and GUI never communicate except when the IDE Client initially sets up the GUI. This ensures that the server is the source-of-truth for state, and that we can easily extend Continue to work in other IDEs.
+
+![Continue Architecture](https://continue.dev/docs/assets/images/continue-architecture-146a90742e25f6524452c74fe44fa2a0.png)
 
 ### Continue VS Code Client
 
@@ -77,18 +108,40 @@ When state is updated on the server, we currently send the entirety of the objec
 - `active`, whether the autopilot is currently running a step. Displayed as a loader while step is running.
 - `user_input_queue`, the queue of user inputs that have not yet been processed due to waiting for previous Steps to complete. Displayed below the `active` loader until popped from the queue.
 - `default_model`, the default model used for completions. Displayed as a toggleable button on the bottom of the GUI.
-- `highlighted_ranges`, the ranges of code that have been selected to include as context. Displayed just above the main text input.
+- `selected_context_items`, the ranges of code and other items (like GitHub Issues, files, etc...) that have been selected to include as context. Displayed just above the main text input.
 - `slash_commands`, the list of available slash commands. Displayed in the main text input dropdown.
 - `adding_highlighted_code`, whether highlighting of new code for context is locked. Displayed as a button adjacent to `highlighted_ranges`.
 
 Updates are sent with `await sdk.update_ui()` when needed explicitly or `await autopilot.update_subscribers()` automatically between each Step. The GUI can listen for state updates with `ContinueGUIClientProtocol.onStateUpdate()`.
 
-## Ways to Contribute
+## ❇️ Core Concepts
+
+All of Continue's logic happens inside of the server, and it is built around a few core concepts. Most of these are Pydantic Models defined in [core/main.py](./continuedev/src/continuedev/core/main.py).
+
+### `Step`
+
+Everything in Continue is a "Step". The `Step` class defines 2 methods:
 
-### Report Bugs
+1. `async def run(self, sdk: ContinueSDK) -> Coroutine[Observation, None, None]` - This method defines what happens when the Step is run. It has access to the Continue SDK, which lets you take actions in the IDE, call LLMs, run nested Steps, and more. Optionally, a Step can return an `Observation` object, which a `Policy` can use to make decisions about what to do next.
 
-### Suggest Enhancements
+2. `async def describe(self, models: Models) -> Coroutine[str, None, None]` - After each Step is run, this method is called to asynchronously generate a summary title for the step. A `Models` object is passed so that you have access to LLMs to summarize for you.
+
+Steps are designed to be composable, so that you can easily build new Steps by combining existing ones. And because they are Pydantic models, they can instantly be used as tools useable by an LLM, for example with OpenAI's function-calling functionality (see [ChatWithFunctions](./continuedev/src/continuedev/steps/chat.py) for an example of this).
 
-### Updating / Improving Documentation
+Some of the most commonly used Steps are:
+
+- [`SimpleChatStep`](./continuedev/src/continuedev/steps/chat.py) - This is the default Step that is run when the user enters natural language input. It takes the user's input and runs it through the default LLM, then displays the result in the GUI.
+
+- [`EditHighlightedCodeStep`](./continuedev/src/continuedev/steps/core/core.py) - This is the Step run when a user highlights code, enters natural language, and presses CMD/CTRL+ENTER, or uses the slash command '/edit'. It opens a side-by-side diff editor, where updated code is streamed to fulfil the user's request.
+
+### `Autopilot`
+
+In [autopilot.py](./continuedev/src/continuedev/core/autopilot.py), we define the `Autopilot` class, which is the central entity responsible for keeping track of state and running the input/action loop.
+
+### `Observation`
+
+An `Observation` is a simple Pydantic model that can be used as a trigger to run a `Step`. For example, if running one `Step` results in an error, this can be returned as an `Observation` that can be used to trigger a `Step` that fixes the error. This is not being used frequently in the codebase right now, but we plan to use it as the basis of various "hooks" that will aid in the development of agents acting within the IDE.
+
+### `Policy`
 
-Continue is continuously improving, but a feature isn't complete until it is reflected in the documentation!
+A `Policy` implements a method `def next(self, config: ContinueConfig, history: History) -> Step`, which decides which `Step` the `Autopilot` should run next. The default policy is defined in [policy.py](./continuedev/src/continuedev/core/policy.py) and runs `SimpleChatStep` by default, or a slash command when the input begins with '/'. It also displays a welcome message at the beginning of each session. If interested in developing agents that autonomously take longer sequences of actions in the IDE, the `Policy` class is the place to start.
diff --git a/continuedev/README.md b/continuedev/README.md
index 528cf75a..d3ead8ec 100644
--- a/continuedev/README.md
+++ b/continuedev/README.md
@@ -1,19 +1,29 @@
 # Continue PyPI Package
 
-This package contains the [Continue](https://github.com/continuedev.com/continue) server and core classes needed to build your own recipes.
+This package contains the [Continue](https://github.com/continuedev/continue) server and core classes needed to build your own recipes.
 
 Continue is a Python library for automating repetitive sequences of software development tasks using language models. Using our VS Code extension, you can build, run, and refine these recipes as they natively interact with your codebase. Read the docs [here](https://continue.dev/docs) or download the VS Code extension [here](https://marketplace.visualstudio.com/items?itemName=Continue.continue).
 
 ## Continue Server
 
-The Continue server acts as a bridge between the Continue React app and your IDE, running your recipes and acting on the codebase. 
+The Continue server acts as a bridge between the Continue React app and your IDE, running your recipes and acting on the codebase.
 
 Start it by running the following commands:
+
 1. `cd continuedev`
 2. Make sure packages are installed with `poetry install`
-3. `poetry shell`
+   - If poetry is not installed, you can install with
+   ```bash
+   curl -sSL https://install.python-poetry.org | python3 -
+   ```
+   (official instructions [here](https://python-poetry.org/docs/#installing-with-the-official-installer))
+3. `poetry shell` to activate the virtual environment
 4. `cd ..`
-5. `python3 -m continuedev.src.continuedev.server.main`
+5. `python3 -m continuedev.src.continuedev.server.main` to start the server
+
+Once you've validated that this works, you'll often want to use a debugger, in which case we've provided a launch configuration for VS Code in `.vscode/launch.json`. To start the debugger in VS Code, ensure that the workspace directory is the root of the `continue` repo, then press F5.
+
+> Note: To start the debugger, you'll have to select the poetry Python interpreter (`/path-to-poetry-venv/bin/python3`) in the bottom right of the VS Code window. If you don't see this, you may have to install the [Python extension](https://marketplace.visualstudio.com/items?itemName=ms-python.python).
 
 ## Scripts
 
@@ -29,6 +39,8 @@ See the `src/continuedev/libs/steps` folder for examples of writing a Continue s
 
 Open a [new GitHub Issue](https://github.com/continuedev/continue/issues/new) or comment on [an existing one](https://github.com/continuedev/continue/issues). Let us know what you would like to contribute, and we will help you make it happen!
 
+For more a more detailed contributing guide, see [CONTRIBUTING.md](../CONTRIBUTING.md).
+
 ## Install from source
 
 #### 1. Clone this repo
@@ -60,4 +72,4 @@ cd continue/extension/scripts && python3 install_from_source.py
 - [Continue GUI README](./extension/react-app/): learn about the React app that lets users interact with the server and is placed adjacent to the text editor in any suppported IDE
 - [Schema README](./schema): learn about the JSON Schema types generated from Pydantic models, which we use across the `continuedev/` and `extension/` directories
 - [Continue Docs README](./docs): learn how our [docs](https://continue.dev/docs) are written and built
-- [How to debug the VS Code Extension README](./extension/src/README.md): learn how to set up the VS Code extension, so you can debug it
\ No newline at end of file
+- [How to debug the VS Code Extension README](./extension/src/README.md): learn how to set up the VS Code extension, so you can debug it
diff --git a/continuedev/src/continuedev/core/policy.py b/continuedev/src/continuedev/core/policy.py
index 1000f0f4..05f03bdc 100644
--- a/continuedev/src/continuedev/core/policy.py
+++ b/continuedev/src/continuedev/core/policy.py
@@ -40,7 +40,7 @@ def parse_custom_command(inp: str, config: ContinueConfig) -> Union[None, Step]:
     return None
 
 
-class DemoPolicy(Policy):
+class DefaultPolicy(Policy):
     ran_code_last: bool = False
 
     def next(self, config: ContinueConfig, history: History) -> Step:
diff --git a/continuedev/src/continuedev/server/session_manager.py b/continuedev/src/continuedev/server/session_manager.py
index 90172a4e..20219273 100644
--- a/continuedev/src/continuedev/server/session_manager.py
+++ b/continuedev/src/continuedev/server/session_manager.py
@@ -7,7 +7,7 @@ import json
 from ..libs.util.paths import getSessionFilePath, getSessionsFolderPath
 from ..models.filesystem_edit import FileEditWithFullContents
 from ..libs.constants.main import CONTINUE_SESSIONS_FOLDER
-from ..core.policy import DemoPolicy
+from ..core.policy import DefaultPolicy
 from ..core.main import FullState
 from ..core.autopilot import Autopilot
 from .ide_protocol import AbstractIdeProtocolServer
@@ -65,7 +65,7 @@ class SessionManager:
                 full_state = FullState(**json.load(f))
 
         autopilot = await DemoAutopilot.create(
-            policy=DemoPolicy(), ide=ide, full_state=full_state)
+            policy=DefaultPolicy(), ide=ide, full_state=full_state)
         session_id = session_id or str(uuid4())
         ide.session_id = session_id
         session = Session(session_id=session_id, autopilot=autopilot)
diff --git a/continuedev/src/continuedev/steps/README.md b/continuedev/src/continuedev/steps/README.md
new file mode 100644
index 00000000..12073835
--- /dev/null
+++ b/continuedev/src/continuedev/steps/README.md
@@ -0,0 +1,50 @@
+# Steps
+
+Steps are the composable unit of action in Continue. They define a `run` method which has access to the entire `ContinueSDK`, allowing you to take actions inside the IDE, call language models, and more. In this folder you can find a number of good examples.
+
+## How to write a step
+
+a. Start by creating a subclass of `Step`
+
+You should first consider what will be the parameters of your recipe. These are defined as attributes in the Pydantic class. For example, if you wanted a "filepath" attribute that would look like this:
+
+```python
+class HelloWorldStep(Step):
+    filepath: str
+    ...
+```
+
+b. Next, write the `run` method
+
+This method takes the ContinueSDK as a parameter, giving you all the tools you need to write your steps (if it's missing something, let us know, we'll add it!). You can write any code inside the run method; this is what will happen when your step is run, line for line. As an example, here's a step that will open a file and append "Hello World!":
+
+```python
+class HelloWorldStep(Step):
+    filepath: str
+
+    async def run(self, sdk: ContinueSDK):
+        await sdk.ide.setFileOpen(self.filepath)
+        await sdk.append_to_file(self.filepath, "Hello World!")
+```
+
+c. Finally, every Step is displayed with a description of what it has done
+
+If you'd like to override the default description of your step, which is just the class name, then implement the `describe` method. You can:
+
+- Return a static string
+- Store state in a class attribute (prepend with a double underscore, which signifies (through Pydantic) that this is not a parameter for the Step, just internal state) during the run method, and then grab this in the describe method.
+- Use state in conjunction with the `models` parameter of the describe method to autogenerate a description with a language model. For example, if you'd used an attribute called `__code_written` to store a string representing some code that was written, you could implement describe as `return models.gpt35.complete(f"{self.\_\_code_written}\n\nSummarize the changes made in the above code.")`.
+
+Here's an example:
+
+```python
+class HelloWorldStep(Step):
+    filepath: str
+
+    async def run(self, sdk: ContinueSDK):
+        await sdk.ide.setFileOpen(self.filepath)
+        await sdk.append_to_file(self.filepath, "Hello World!")
+
+    def describe(self, models: Models):
+        return f"Appended 'Hello World!'  to {self.filepath}"
+```
diff --git a/docs/docs/customization.md b/docs/docs/customization.md
index cd306cfe..9e04280d 100644
--- a/docs/docs/customization.md
+++ b/docs/docs/customization.md
@@ -79,7 +79,7 @@ When you type '@' in the Continue text box, it will display a dropdown of items
 ```python
 class GitHubIssuesContextProvider(ContextProvider):
     """
-    The GitHubIssuesContextProvider is a ContextProvider that allows you to search GitHub Issues in a repo.
+    The GitHubIssuesContextProvider is a ContextProvider that allows you to search GitHub issues in a repo.
     """
 
     title = "issues"
@@ -93,7 +93,7 @@ class GitHubIssuesContextProvider(ContextProvider):
         repo = gh.get_repo(self.repo_name)
         issues = repo.get_issues().get_page(0)
 
-        items = [ContextItem(
+        return [ContextItem(
             content=issue.body,
             description=ContextItemDescription(
                 name=f"Issue #{issue.number}",
@@ -104,9 +104,6 @@ class GitHubIssuesContextProvider(ContextProvider):
                 )
             )
         ) for issue in issues]
-        self.context_items = {
-            item.description.id.to_string(): item for item in items}
-        return items
 ```
 
 It can then be set in the `ContinueConfig` like so:
diff --git a/extension/DEV_README.md b/extension/DEV_README.md
index 87ed9334..72ea5c6a 100644
--- a/extension/DEV_README.md
+++ b/extension/DEV_README.md
@@ -6,8 +6,17 @@ This is the Continue VS Code Extension. Its primary jobs are
 2. Open the Continue React app in a side panel. The React app's source code lives in the `react-app` directory. The panel is opened by the `continue.openContinueGUI` command, as defined in `src/commands.ts`.
 3. Run a Continue server in the background, which connects to both the IDE protocol and the React app. The server is launched in `src/activation/environmentSetup.ts` by calling Python code that lives in `server/` (unless extension settings define a server URL other than localhost:65432, in which case the extension will just connect to that).
 
-4. Open Continue
+## Setting up for development
 
-# Notes
+1. Clone this repo
+2. `cd extension`
+3. `npm run full-package`
+
+   > If NPM is not installed, you can use `brew install node` on Mac, or see the [installation page](https://docs.npmjs.com/downloading-and-installing-node-js-and-npm) for other platforms, or more detailed instructions.
+
+4. Open a VS Code window with `/extension` as the workspace root (_this is important, development mode will not work otherwise_)
+5. Open any `.ts` file in the workspace, then press F5 and select "VS Code Extension Development" to begin debugging.
+
+## Notes
 
 - We require vscode engine `^1.67.0` and use `@types/vscode` version `1.67.0` because this is the earliest version that doesn't break any of the APIs we are using. If you go back to `1.66.0`, then it will break `vscode.window.tabGroups`.
diff --git a/extension/package.json b/extension/package.json
index 08737ff4..6ab2d74a 100644
--- a/extension/package.json
+++ b/extension/package.json
@@ -227,7 +227,7 @@
     "test": "node ./out/test/runTest.js",
     "jest": "jest --config ./jest.config.js",
     "package": "cp ./config/prod_config.json ./config/config.json && mkdir -p ./build && vsce package --out ./build && cp ./config/dev_config.json ./config/config.json",
-    "full-package": "cd ../continuedev && poetry build && cp ./dist/continuedev-0.1.2-py3-none-any.whl ../extension/server/continuedev-0.1.2-py3-none-any.whl && cd ../extension && npm install && npm run typegen && npm run clientgen && cd react-app && npm install && npm run build && cd .. && npm run package",
+    "full-package": "cd ../continuedev && poetry install && poetry build && cp ./dist/continuedev-0.1.2-py3-none-any.whl ../extension/server/continuedev-0.1.2-py3-none-any.whl && cd ../extension && npm install && npm run typegen && npm run clientgen && cd react-app && npm install && npm run build && cd .. && npm run package",
     "install-extension": "code --install-extension ./build/continue-0.0.8.vsix",
     "uninstall": "code --uninstall-extension .continue",
     "reinstall": "rm -rf ./build && npm run package && npm run uninstall && npm run install-extension"