Chatty for VS Code

Run Locally

1. Open this folder in VS Code.
2. Install dependencies if needed:

   npm install
   

3. Install uv if it is not already available. Chatty uses it to provision Python 3.13 and the pinned Microsoft Semantic Kernel environment outside the repository. Alternatively, set chatty.semanticKernelPythonPath to a Python 3.10–3.13 executable where python/requirements.txt is installed.
4. Build the extension:

   npm run compile
   

5. Press F5 to launch the Extension Development Host.
6. In the new VS Code window, open the Chatty icon in the activity bar.

What You Should See

• A Chatty activity bar entry
• A chat sidebar view
• New Chat and Clear History actions
• Microsoft Semantic Kernel agent replies when you send a message

Runtime Architecture

• The VS Code extension owns UI integration and executes registered VS Code/MCP tools.
• The official Microsoft Semantic Kernel Python ChatCompletionAgent owns conversation execution, function selection, and the agent loop.
• A JSON-lines sidecar protocol carries streamed content and tool calls between Semantic Kernel and VS Code.
• Models are accessed through Semantic Kernel's OpenAI-compatible connector, so local servers and hosted compatible endpoints continue to work.

Useful Commands

• npm run compile builds the extension into out/
• npm run lint checks the TypeScript sources
• F5 runs the extension with the local debug config in .vscode/launch.json

---

ROADMAP.md

VS Code Agent - Chatty for VS Code

Vision

Build a lightweight, fast and intelligent VS Code extension that acts as a true coding agent.

Unlike existing coding assistants that immediately load large amounts of project context, this agent will follow a minimal-context-first philosophy.

The model should only receive information that is absolutely necessary to answer the current request.

The extension (agent) will be responsible for interacting with the developer's workspace while the LLM focuses only on reasoning and decision making.

---

The Problem

Current coding assistants such as Kilo, Cline and similar agents often:

• Automatically scan the workspace
• Read dozens of files
• Perform semantic searches
• Send huge conversations
• Exhaust local model context
• Become slow on CPU-hosted models

This approach works well for cloud models with massive context windows, but performs poorly on local models.

For a local model running through llama.cpp, efficiency is far more important than brute-force context.

---

Our Philosophy

The model should never receive unnecessary information.

Instead, everything should happen as a conversation.

User asks.

↓

Model thinks.

↓

Model requests information.

↓

Agent executes tools.

↓

Agent returns results.

↓

Model continues reasoning.

The model never directly edits files.

The model never directly runs commands.

The model only decides what should happen next.

The extension performs the work.

---

Design Principles

1. Minimal Context First

Every request starts with only:

• User Prompt
• Small conversation history
• Current file (optional)

Nothing else.

No workspace scanning.

No indexing.

No semantic search.

---

2. Pull Context Only When Needed

The model should explicitly ask for information.

Example:

"I need to inspect frappe/www/index.html"

Agent reads the file.

Returns its contents.

Model continues.

---

3. Every Action Is A Tool

The model never performs actions itself.

Instead it requests tools.

Example

read_file()

list_directory()

replace_text()

run_terminal()

write_file()

etc.

---

4. Human Approval

Potentially destructive operations should require confirmation.

Examples

Delete files

Run migrations

Git operations

Large refactors

---

High Level Architecture

User

↓

VS Code Chat UI

↓

Agent Controller

↓

Local Qwen Model

↓

Tool Request

↓

Agent Executes Tool

↓

Returns Tool Result

↓

Model Continues Reasoning

↓

Final Response

---

Project Phases

Phase 1 — Foundation

Goal:

Create a functioning VS Code extension.

Tasks

• Create Extension
• Sidebar Chat
• Command Palette entry
• Message streaming
• Chat history
• Theme support

---

Phase 2 — Model Integration

Goal

Connect to local OpenAI-compatible API.

Settings

• Base URL
• API Key (optional)
• Model Name
• Temperature
• Max Tokens
• Streaming
• Timeout

Example

http://144.91.83.180:8080

---

Phase 3 — Agent Core

This becomes the brain of the extension.

Responsibilities

• Maintain conversation
• Execute tools
• Send tool results
• Handle retries
• Handle errors
• Control context

No tool executes without the agent.

---

Phase 4 — Tool System

Initial tools

Files

• read_file
• write_file
• replace_file
• create_file
• delete_file

Workspace

• list_directory
• find_files

Terminal

• run_command

VS Code

• open_file
• reveal_location
• show_diff

Every tool returns structured JSON.

---

Phase 5 — Agent Loop

Workflow

User Request

↓

Model Response

↓

Tool Call

↓

Agent Executes Tool

↓

Tool Result

↓

Model Continues

↓

Repeat until complete

↓

Final Answer

---

Context Engine

This is the most important component.

Rules

Start with almost zero context.

Never preload the project.

Never scan the repository.

Only provide files when requested.

Provide one file at a time.

Keep conversation short.

Summarize old history.

The context engine exists to protect local models.

---

Safety

Always preview edits.

Never overwrite files silently.

Always allow undo.

Show diffs.

Log tool usage.

---

Settings

Initial settings page

Model

• Base URL
• Model Name
• API Key
• Temperature
• Max Tokens
• Stream Responses

Agent

• Auto Approve Safe Tools
• Ask Before Terminal Commands
• Ask Before File Writes
• Maximum Files Per Request
• Maximum Tool Iterations

Context

• Max Conversation History
• Max Files In Context
• Enable Auto Summary
• Current File Only Mode

---

Future Features

• Multiple model support
• Anthropic/OpenAI compatibility
• Ollama support
• Workspace memory
• Frappe-aware tools
• Git integration
• Background indexing (optional)
• Test runner
• Browser automation
• Database tools
• MCP support

---

Success Criteria

The extension should feel fast even on a local CPU model.

The model should spend time reasoning instead of reading unnecessary files.

The extension should control the workspace.

The model should control the thinking.

The architecture should remain model-agnostic so future LLMs can be swapped without redesigning the extension.

---

Guiding Principle

The LLM is the brain.

The VS Code extension is the hands.

The Context Engine is the gatekeeper.

Keep the brain focused.

Keep the hands capable.

Keep the context minimal.