⚡ Jessie — AI Coding Agent

Sits in front of GitHub Copilot. Coaches prompts, injects codebase context, picks the right model automatically, quality-checks every response, and remembers what your team builds.

What Jessie Does

Without Jessie you type a vague prompt → Copilot guesses → you get mediocre code.

With Jessie:

You type:  "add a date picker to the booking form"
           ↓
Jessie:    Detects language (TypeScript), reads your open file,
           finds 4 relevant files in your codebase via RAG,
           rewrites your prompt with full context,
           picks the right Copilot model (complexity score 5/10 → gpt-4o),
           sends to Copilot, scores the output (rubric: 7 checks),
           retries if quality < 70/100,
           saves the new component to project memory so next time
           anyone asks — Jessie reuses it instantly.
           ↓
You get:   Production-ready code, first time.

Prerequisites

Before installing Jessie make sure you have:

Installation

Option A — VS Code Marketplace (Recommended)

1. Open VS Code
2. Press Ctrl+Shift+X to open Extensions
3. Search "Jessie AI"
4. Click Install
5. Done — skip to Backend Setup

Option B — Install from VSIX (Manual)

If you received a .vsix file:

1. Open VS Code
2. Press Ctrl+Shift+X
3. Click the ⋯ menu (top-right of Extensions panel)
4. Select Install from VSIX...
5. Browse to jessie-ai-1.0.0.vsix and open it
6. Reload VS Code when prompted
7. Continue to Backend Setup

Option C — Build from Source

# 1. Clone the repo
git clone https://github.com/vijaay-arther/jessie-ai
cd jessie-ai/extension

# 2. Install dependencies
npm install

# 3. Compile TypeScript
npm run compile

# 4. Press F5 in VS Code to launch Extension Development Host

Backend Setup

Jessie needs a Python backend running locally (or on your team server).

Step 1 — Run the Setup Wizard

After installing the extension:

1. Press Ctrl+Shift+P
2. Type Jessie: Setup Jessie Backend
3. Press Enter

The wizard will:

• ✅ Find Python 3.9+ on your machine
• ✅ Find the Jessie backend folder
• ✅ Install all Python dependencies (pip install)
• ✅ Start the backend server on http://localhost:8000

When you see "Jessie is ready!" — you're done.

Step 2 — Manual Backend Start (Alternative)

If the wizard fails or you prefer the terminal:

cd jessie-ai/backend
pip install -r requirements.txt
python -m uvicorn api.main:app --reload --port 8000

You should see:

INFO:     Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
INFO:     Started reloader process

Step 3 — Configure Your User ID

1. Press Ctrl+, to open Settings
2. Search jessie
3. Set Jessie: User Id — your name or team ID (e.g. vijay)

This is used to track your daily request count.

How to Use Jessie

Method 1 — Copilot Chat (Recommended)

1. Open Copilot Chat: Ctrl+Alt+I
2. Type @jessie followed by your task:

@jessie fix the login error in auth.ts
@jessie add a date picker to the booking form
@jessie refactor the getUserData function to be async
@jessie create a reusable Button component with loading state

Jessie handles everything automatically — no approval steps, no extra windows.

Method 2 — Keyboard Shortcut

Press Ctrl+Shift+J (Mac: Cmd+Shift+J) from anywhere in VS Code.

A prompt box appears. Type your task and press Enter. Results appear in the Jessie sidebar panel (⚡ icon in the Activity Bar).

Method 3 — Command Palette

1. Ctrl+Shift+P
2. Type Ask Jessie
3. Type your task

What Happens Internally (Full Flow)

Your prompt
    │
    ▼
[1] SUPERVISOR
    • Detects language from your open file
    • Generates a workspace ID (memory is scoped per repo)
    • On retry: injects failure reason into prompt

    ▼
[2] PROMPT COACH
    • Scores your prompt quality (1–10)
    • Classifies task complexity (1–10)
    • Rewrites prompt with:
        - Language context
        - Your open file (first 4000 chars)
        - Selected code snippet
        - Any terminal error messages
        - Output constraints

    ▼
[3] RAG INJECTOR  (skipped if complexity ≤ 2)
    • Checks if this component already exists in your project memory
      → YES: returns existing code, skips Copilot entirely
      → NO:  scans your codebase, injects top 4 relevant file chunks

    ▼
[4] MODEL SELECTION + COPILOT CALL
    Complexity 1–3  →  gpt-4o-mini   (fast, cheap — typos, renames)
    Complexity 4–7  →  gpt-4o        (standard — functions, hooks)
    Complexity 8–10 →  claude-sonnet (most capable — architecture, auth)

    ▼
[5] QUALITY ANALYSER
    Scores output against 7-point rubric (max 100):
    +20  Has real code (not just explanation text)
    +15  No TODOs or placeholder stubs
    +15  Has error handling (try/catch, optional chaining)
    +15  Code matches detected language
    +15  Correct scope (not a full file dump)
    +10  Has comments or explanation
    +10  Response under 150 lines

    Score ≥ 70 → Delivered
    Score < 70 → Auto retry (up to 2 times with failure feedback)

    ▼
[6] MEMORY WRITER  (only if quality ≥ 70)
    • Detects if a new component was created (PascalCase export)
    • Saves to project memory with file path + usage example
    • Next time anyone asks for this component → instant reuse
    • Saves your prompt pattern to user memory
    • Increments daily request count

Settings Reference

Commands Reference

Troubleshooting

❌ "Jessie backend is not running"

The Python backend isn't started. Fix:

cd jessie-ai/backend
python -m uvicorn api.main:app --reload --port 8000

If port 8000 is taken:

python -m uvicorn api.main:app --reload --port 8001
# Then update Settings → Jessie: Backend Url → http://localhost:8001

❌ "No Copilot model found"

GitHub Copilot is not active. Fix:

1. Open Extensions (Ctrl+Shift+X)
2. Search GitHub Copilot — make sure it is installed and enabled
3. Click the Copilot icon in the status bar and sign in if prompted
4. Reload VS Code and try again

❌ pip install failed — conflicting dependencies

# Fix: upgrade pip first, then install
python -m pip install --upgrade pip
pip install -r requirements.txt

If still failing:

# Install in a virtual environment
python -m venv venv
venv\Scripts\activate        # Windows
source venv/bin/activate     # Mac/Linux
pip install -r requirements.txt
python -m uvicorn api.main:app --reload

❌ error TS5057: Cannot find tsconfig.json

The tsconfig.json is missing. Fix:

cd extension
# Create tsconfig.json with this content:

{
  "compilerOptions": {
    "module": "commonjs",
    "target": "ES2020",
    "lib": ["ES2020"],
    "outDir": "./out",
    "rootDir": "./src",
    "sourceMap": true,
    "strict": true,
    "esModuleInterop": true,
    "skipLibCheck": true
  },
  "include": ["src"],
  "exclude": ["node_modules", ".vscode-test"]
}

❌ ModuleNotFoundError: No module named 'core'

Missing __init__.py files in the backend. Fix — run this from the backend/ folder:

# Windows PowerShell
@("__init__", "api/__init__", "core/__init__", "agents/__init__",
  "agents/prompt_coach/__init__", "agents/rag_injector/__init__",
  "agents/memory_writer/__init__", "agents/quality_analyser/__init__",
  "memory/__init__", "mcp/__init__") | ForEach-Object {
    New-Item -ItemType File -Path "$_.py" -Force
}

# Mac/Linux
touch __init__.py api/__init__.py core/__init__.py agents/__init__.py \
  agents/prompt_coach/__init__.py agents/rag_injector/__init__.py \
  agents/memory_writer/__init__.py agents/quality_analyser/__init__.py \
  memory/__init__.py mcp/__init__.py

❌ Backend starts but Setup says "did not start in time"

The health check timed out. The backend may have started successfully anyway. Check:

curl http://localhost:8000/health
# Should return: {"status":"ok","version":"1.0.0"}

If that works, Jessie is running. Restart VS Code — the status bar should show "Jessie — ready".

❌ Setup wizard shows invisible/dark text

Reload the Extension Development Host window: Ctrl+Shift+P → Developer: Reload Window

❌ @jessie does not appear in Copilot Chat

1. Make sure the extension is installed and active (check status bar for the ⚡ icon)
2. Reload VS Code: Ctrl+Shift+P → Developer: Reload Window
3. Open Copilot Chat with Ctrl+Alt+I
4. Type @ — Jessie should appear in the participant list

Note: @jessie only works in VS Code's built-in Copilot Chat panel. It does not appear in Claude Code's chat (which has a separate isolated UI). Use Ctrl+Shift+J as the universal trigger that works everywhere.

Publishing to VS Code Marketplace

One-time Setup

1. Create a Microsoft account at marketplace.visualstudio.com
2. Create a publisher:
   • Go to Manage Publishers
   • Click Create publisher
   • Choose a publisher ID (e.g. vijay-arther)
3. Create a Personal Access Token (PAT):
   • Go to dev.azure.com
   • User Settings → Personal Access Tokens → New Token
   • Scope: Marketplace → Manage
   • Copy the token

Publish

cd extension

# Login with your PAT
npx vsce login vijay-arther

# Package into a .vsix file first (to inspect before publishing)
npm run package
# Creates: jessie-ai-1.0.0.vsix

# Publish to Marketplace
npx vsce publish

Update an Existing Version

# Bump patch version (1.0.0 → 1.0.1)
npx vsce publish patch

# Bump minor version (1.0.0 → 1.1.0)
npx vsce publish minor

Team Hosting the Backend

To share one backend across your team:

# On your server
git clone https://github.com/vijaay-arther/jessie-ai
cd jessie-ai/backend
pip install -r requirements.txt
python -m uvicorn api.main:app --host 0.0.0.0 --port 8000

Each team member updates their VS Code setting:

• Jessie: Backend Url → http://your-server-ip:8000

Memory is scoped per workspace_id (hash of the repo path), so there is zero cross-project leakage.

FAQ

Q: Does Jessie send my code to any third-party server?
A: No. The backend runs locally (or on your own team server). Jessie only calls GitHub Copilot — the same model you're already using.

Q: Will Jessie slow down my workflow?
A: Phase 1 (prompt coaching + RAG) takes ~200–500ms. Copilot call time is unchanged. The quality check adds ~100ms. Total overhead is under 1 second for most tasks.

Q: What if the backend is down?
A: Jessie shows a clear error in the chat with the command to restart it. Your Copilot still works normally via the built-in chat.

Q: Does it work offline?
A: The backend works offline. Copilot requires internet.

Q: How is team memory scoped?
A: Every workspace gets a unique ID based on its folder path. Project memory (components, patterns) is scoped to that ID. User memory (your prompt style, request count) is scoped to your jessie.userId.

License

MIT — see LICENSE