PromptEngineer

A VS Code extension that brings the asl-parser CLI into the editor and adds a real local RAG index that lives entirely on your machine. No API keys, no cloud, no telemetry. Code, index, and prompts never leave the workspace.

This extension re-implements and extends the original asl-parser features (parse, prompt, rag) as native VS Code commands, plus a persistent RAG index, file watching, tree views, and webview result panels.

Features

Quick start

1. Install the VSIX:

   cd PromptEngineer
   npm install
   npm run build
   npx vsce package
   code --install-extension promptengineer-0.1.0.vsix
   

   Or, while developing, copy this folder into ~/.vscode/extensions/ and run npm install && npm run build there, then restart VS Code.

2. Open a workspace in VS Code.

3. Build the index (one-time per workspace):

   • Command Palette → PromptEngineer: Build Local RAG Index
   • Or click the status bar item: PE · no index

4. Search the index:

   • Ctrl+Shift+R → PromptEngineer: RAG Search Codebase
   • Type a query, hit Enter, results appear in a side webview.

5. Run an impact analysis:

   • Ctrl+Shift+I → PromptEngineer: Analyze Prompt Impact
   • Describe the change in one sentence.

6. Generate agents.md:

   • Ctrl+Shift+P → PromptEngineer: Parse Workspace to agents.md
   • The file is written to the workspace root and a preview opens in a side webview.

Commands

Configuration

All settings live under PromptEngineer in VS Code settings:

How the local RAG works

• Indexing (src/services/ragService.ts): walks the workspace respecting ignoreDirs and codeExtensions, reads each file, splits it into overlapping chunks of chunkSize lines with chunkOverlap overlap, and extracts lightweight context (function/class names, path parts) for each chunk. Each chunk gets a stable hash ID.
• Persistence: the index is written to .promptengineer/index.json in your workspace root. It survives VS Code restarts.
• Incremental updates: a FileSystemWatcher debounces file change events (500 ms) and re-indexes only files whose mtime/size changed. Unchanged chunks are kept from the prior index.
• Search: lexical BM25-lite — tokenizes the query, scores each chunk by token occurrences in the content (×2), context keywords (×1.5), and file path (×3). Returns top-K with a normalized 0–100% relevance.
• Privacy: nothing is sent off your machine. The index file is plain JSON and you can .gitignore it if you don't want to commit it.

Where things live in the project

PromptEngineer/
├── package.json                  # extension manifest
├── tsconfig.json                 # TypeScript config
├── esbuild.config.mjs            # bundler config
├── .vscodeignore                 # VSIX exclude rules
└── src/
    ├── extension.ts              # activate(), status bar, wiring
    ├── commands/
    │   ├── parseCommand.ts       # parse + open agents.md
    │   ├── promptCommand.ts      # impact analysis
    │   ├── ragCommand.ts         # RAG search + snippet helpers
    │   └── indexCommand.ts       # build / clear / refresh / reindex
    ├── services/
    │   ├── parserService.ts      # file walking, function/class detection, agents.md generator
    │   ├── promptAnalyzer.ts     # keyword extraction + impact scoring
    │   ├── ragService.ts         # chunking, indexing, watching, search
    │   └── recentStore.ts        # recent-searches JSON store
    ├── providers/
    │   ├── ragExplorerProvider.ts    # Local RAG Index tree view
    │   └── recentSearchesProvider.ts # Recent searches tree view
    ├── webviews/
    │   ├── ragResultsPanel.ts    # RAG results webview
    │   ├── impactPanel.ts        # impact analysis webview
    │   └── parseReportPanel.ts   # agents.md preview webview
    └── utils/
        ├── config.ts             # settings + paths
        └── types.ts              # shared TypeScript types

Compared to the original asl-parser CLI

The extension additionally adds:

• A persistent on-disk index (the CLI re-indexed on every run).
• A file watcher for incremental updates.
• A tree view of indexed files and recent searches.
• A status bar indicator.
• Result webviews with click-to-open and copy-snippet actions.
• A walkthrough that walks a new user through the three core commands.

Development

npm install
npm run watch      # rebuild on save
npm run lint       # tsc --noEmit
npm run build      # one-shot bundle
npx vsce package   # produce a VSIX

To run inside VS Code: open this folder, press F5 (it'll spawn an Extension Development Host).

Limitations

• The RAG is lexical, not semantic. It scores token overlap, not meaning. For most "find me the function that does X" tasks this is fast and accurate; for fuzzy concept search you'll want to add embeddings (a future extension point).
• The language heuristics for function/class detection cover JS/TS/Python/Java/Go/Rust/Ruby/PHP/Kotlin. Other languages are indexed and searched but not auto-tagged.
• Very large monorepos: the index is one JSON file. For 100k+ files, swap the storage layer in src/services/ragService.ts for SQLite or similar.

License

Apache-2.0 (same as the original asl-parser).