Chat With Code

Overview

Chat With Code is yet another command-line application that bridges the gap between coding and conversation. This tool lets you engage with your codebases using natural language prompts, offering a fresh approach to code exploration and problem-solving.

Why does this tool exist?

I was frequently disappointed with Github Copilot's chat context discovery, as it often missed relevant files for accurate answers. CWC improves this by allowing you to specify include and exclude patterns across your codebase, giving you complete control over the context window during chats. Additionally, its terminal-based operation makes it independent of IDEs like VSCode, enhancing flexibility with other text editors not natively supporting Github Copilot.

Features

Interactive Chat Sessions: Start a dialogue with your codebase to learn about its structure, get summaries of different parts, or even debug issues.
Intelligent Context-Aware Responses: Powered by OpenAI, Chat With Code understands the context of your project, providing meaningful insights and relevant code snippets.
Customizable File Inclusion: Filter the files you want the tool to consider using regular expressions, ensuring focused and relevant chat interactions.
Gitignore Awareness: Exclude files listed in .gitignore from the chat context to maintain confidentiality and relevance.
Simplicity: A simple and intuitive interface that requires minimal setup to get started.

Installation

Using homebrew

Intility provides a shared Homebrew tap with all our formulae. Install Chat With Code using:

brew tap intility/tap
brew install cwc

Using Go

If you have Go installed (version 1.22 or higher), you can install Chat With Code using the following command:

go install github.com/intility/cwc@latest

Pre-built Binaries

We also provide pre-built binaries for Windows, macOS, and Linux. You can download them from the releases page on GitHub. You can install the latest release with the following command using a bash shell (git bash or WSL on Windows):

bash <(curl -sSL https://raw.githubusercontent.com/intility/cwc/main/scripts/install.sh)

# move the binary to a directory in your PATH
mv cwc /usr/local/bin

Getting Started

After installing Chat With Code, you're just a few steps away from a conversational coding experience. Get everything up and running with these instructions:

Launch Chat With Code: Open your terminal and enter cwc to start an interactive session with your codebase. If you are not already signed you will be prompted to configure your credentials.
Authenticate: To enable communication with your code, authenticate using your Azure credentials by executing:
```
cwc login
```
For a seamless login experience, follow the non-interactive authentication method below:
1. Safeguard your API Key by storing it in a variable (avoid direct command-line input to protect the key from your history logs):
```
read -s API_KEY
```
2. Authenticate securely using the following command:
```
cwc login \
  --api-key=$API_KEY \
  --endpoint "https://your-endpoint.openai.azure.com/" \
  --deployment-name "gpt-4-turbo"
```
Security Notice: Never input your API key directly into the command-line arguments to prevent potential exposure in shell history and process listings. The API key is securely stored in your personal keyring.

After completing these steps, you will have established a secure session, ready to explore and interact with your codebase in the most natural way.

Need a more tailored experience? Try customizing your session. Use the --include, --exclude flag to filter for specific file patterns or --paths to set directories included in the session. Discover all the available options with:

cwc --help

Example usage

The simplest example would be to chat with a single file or output from a command. This use-case is easy using a pipe:

cat README.md | cwc "help me rewrite the getting started section"

If you have multiple files you want to include in the context you can provide a regular expression matching your criteria for inclusion using the -i flag:

# chat across all .go files
cwc -i ".*.go"

# chat with README and test files
cwc -i "README.md|.*_test.go"

The include flag can also be combined with exclusion expressions, these work exactly the same as the inclusion patterns, but takes priority:

# chat with all .ts files, excluding a large .ts file
cwc -i ".*.ts$" -x "large_file.ts"

In addition to include and exclude expressions you can also scope the search space to a particular directory. Multiple paths can be provided by a comma separated list or by providing multiple instances of the -p flag.

# chat with everything inside src/ except .tsx files
cwc -x ".*.tsx" -p src

# chat with all yaml files in prod and lab
cwc -i ".*.ya?ml" -p prod,lab

The result output from cwc can also be piped to other commands as well. This example automates the creation of a conventional commit based on the current git diff.

# generate a commit message for current changes
PROMPT="please write me a conventional commit for these changes"
git diff HEAD | cwc $PROMPT | git commit -e --file -

Configuration

Managing your configuration is simple with the cwc config command. This command allows you to view and set configuration options for cwc. To view the current configuration, use:

cwc config get

To set a configuration option, use:

cwc config set key1=value1 key2=value2 ...

For example, to disable the gitignore feature and the git directory exclusion, use:

cwc config set useGitignore=false excludeGitDir=false

To reset the configuration to default values use cwc login to re-authenticate.

Templates

Overview

Chat With Code (CWC) introduces the flexibility of custom templates to enhance the conversational coding experience. Templates are pre-defined system messages and prompts that tailor interactions with your codebase. A template envelops default prompts, system messages and variables, allowing for easier access to common tasks.

Template Schema

Each template follows a specific YAML schema defined in templates.yaml. Here's an outline of the schema for a CWC template:

templates:
  - name: template_name
    description: A brief description of the template's purpose
    defaultPrompt: An optional default prompt to use if none is provided
    systemMessage: |
      The system message that details the instructions and context for the chat session.
      This message supports placeholders for {{ .Context }} which is the gathered file context,
      as well as custom variables `{{ .Variables.variableName }}` fed into the session with cli args.
    variables:
      - name: variableName
        description: Description of the variable
        defaultValue: Default value for the variable

Placement

Templates may be placed within the repository or under the user's configuration directory, adhering to the XDG Base Directory Specification:

In the Repository Directory: To include the templates specifically for a repository, place a templates.yaml inside the .cwc directory at the root of your repository:
```
.
├── .cwc
│   └── templates.yaml
...
```
In the User XDG CWC Config Directory: For global user templates, place the templates.yaml within the XDG configuration directory for CWC, which is typically ~/.config/cwc/ on Unix-like systems:
```
$XDG_CONFIG_HOME/cwc/templates.yaml
```
If $XDG_CONFIG_HOME is not set, it defaults to ~/.config.

Example Usage

You can specify a template using the -t flag and pass variables with the -v flag in the terminal. These flags allow you to customize the chat session based on the selected template and provided variables.

Selecting a Template

To begin a chat session using a specific template, use the -t flag followed by the template name:

cwc -t my_template

This command will start a conversation with the system message and default prompt defined in the template named my_template.

Passing Variables to a Template

You can pass variables to a template using the -v flag followed by a key-value pair:

cwc -t my_template -v personality="a helpful assistant",name="Juno"

Here, the my_template template is used. The personality variable is set to "a helpful coding assistant", and the name variable is set to "Juno". These variables will be fed into the template's system message where placeholders are specified.

The template supporting these variables might look like this:

name: my_template
description: A custom template with modifiable personality and name
systemMessage: |
  You are {{ .Variables.personality }} named {{ .Variables.name }}. 
  Using the following context you will be able to help the user.

  Context:
  {{ .Context }}
   
  Please keep in mind your personality when responding to the user.
  If the user asks for your name, you should respond with {{ .Variables.name }}.
variables:
  - name: personality
    description: The personality of the assistant. e.g. "a helpful assistant"
    defaultValue: a helpful assistant
  - name: name
    description: The name of the assistant. e.g. "Juno"
    defaultValue: Juno

Notice that the personality and name variables have default values, which will be used if no value is provided in the -v flag.

Roadmap

These items may or may not be implemented in the future.

tests
support both azure and openai credentials
customizable tools

Contributing

Please file an issue if you encounter any problems or have suggestions for improvement. We welcome contributions in the form of pull requests, bug reports, and feature requests.

License

Chat With Code is provided under the MIT License. For more details, see the LICENSE file.

If you encounter any issues or have suggestions for improvement, please open an issue in the project's issue tracker.