🧠 Persistent AI Memory Moat: Keeps project context intact across chat sessions via version-controlled .avvarre/ markdown files and a local SQLite memory.db store. Features iterative <private> tag redaction, multi-stage deduplication (5-minute in-memory burst, 15-minute rolling hash, Jaccard token similarity, and ONNX cosine embedding similarity), topic-key revisions, and hybrid RRF search () with project-isolated SQL filtering.
AI context that survives the chat window. Persistent repo memory, impact analysis, and instant style audits in one command.
स्टार
4
टूल
—
अपटाइम
—
FTS5 + Vector + Graph
🕸️ AST Code Review Graph (On-Demand Freshness): SQLite-backed dependency tracker across 15 languages using web-tree-sitter. Re-indexes affected files on edit events with hash-checked parsing (<5ms unchanged, <50ms changed) and calculates blast-radius impact warnings before code modifications.
🎯 Smart Stack & Community Skill Detector: Scans project manifests (package.json, requirements.txt, go.mod, etc.), framework signatures, and file extensions to suggest community rules from awesome-cursorrules, complete with project-level skill suppression tracking (.declined.json). Fully validated by 74 vitest unit tests.
🔄 Autopilot Self-Correction Loop: Enables agents to run /avvarre:autopilot to autonomously resolve code style and structural violations until achieving a Grade A (90+) quality score.
🪝 Multi-IDE Lifecycle Hooks: Integrates into bootstrap, prompt loading, impact warning, and session sync lifecycle events across 6 major IDE plugins.
🔌 Universal IDE Portability: Operates as a unified Model Context Protocol (MCP) server compatible with Codex, Cursor, Claude Code, Antigravity 2.0, VS Code + GitHub Copilot, and OpenCode.
⚡ Instant Style Guide Audits: Analyzes source code locally against 732 Google Style Guide rules across 21 languages in under 100ms with zero API keys or external dependencies.
🛠️ Tech Stack
Core Language: TypeScript
Runtime: Node.js (v22.5+ required for native node:sqlite)
Parsing Engine:web-tree-sitter (Wasm-based Abstract Syntax Tree parsing, bundled per plugin hooks/graph/wasm/)
Database: SQLite (built-in via node:sqlite, WAL, graph.db time-boxed 8s + on-demand, memory.db long-term FTS5+vectorsrc/memory/store.ts:1 + memory-schema.sql with soft-delete deleted_at + idx_memories_deleted and FTS purge memories_fts_update_delete/insert v3 migration memory-connection.ts:33)
Testing:vitest + @vitest/coverage-v8 (74 tests across 6 files + harness R@5 93.3%, vitest.config.ts:13 includes memory/graph)
Supported Environments: Codex, Cursor, Claude Code, VS Code / GitHub Copilot, Antigravity 2.0, OpenCode
🚀 Getting Started
1. Prerequisites
Ensure you have Node.js (v22.5 or higher) and npm installed on your local environment. Node 22.5+ is required for the built-in node:sqlite module used by the AST graph engine.
2. Installation
Initialize all compatible local IDE configurations in a single command:
Trigger avvarre directly inside your editor or terminal prompt chat:
/avvarre - Audit the currently active file.
/avvarre-workspace - Perform a full repository quality and memory scan.
/avvarre-pr - Audit staged files before commit.
/avvarre-init - Initialize the local .avvarre/ directory in your workspace.
/avvarre-autopilot - Start the autonomous quality remediation loop.
/avvarre-garden - Audit the persistent memory directory for context drift and stale tasks.
In Codex, these workflows are bundled as Avvarre skills. Select them from the skill picker or invoke them explicitly with $avvarre, $avvarre-init, $avvarre-workspace, $avvarre-pr, $avvarre-autopilot, or $avvarre-garden.
CLI Commands
avvarre can be executed directly from your terminal:
npx avvarre install [--global|--local|--both] [--cursor] [--claude] [--vscode] [--opencode] [--codex] [--antigravity] - Install the MCP server configuration and agent plugins into your IDEs.
npx avvarre check --file <path> [--format score-only|full] [--light|--fts-only] - Quickly analyze and check the quality score and violations of a specific file. --light/AVVARRE_LIGHT=1 = FTS-only (skip 90MB vector model).
MCP Tools
avvarre exposes 17 MCP tools that can be invoked programmatically:
avvarre_file: Runs local rules analysis and outputs quality score, list of violations, and drop-in fixes. Takes workspaceRoot to auto-log to history.
avvarre_workspace: Scans the entire project and outputs a quality score heatmap. Configurable via ai_depth, include_badge, include_trends.
avvarre_pr: Evaluates staged git changes and fails below a threshold score (minScoreThreshold, default 80).
avvarre_get_impact: Queries the AST graph to analyze modification blast-radius, dependency risk scores, and coverage gaps.
list_rules: Lists available Google Style Guide rules, filterable by language.
scaffold_avvarre: Guided interactive setup for .avvarre/ workspace assets.
setup_claude_code: Bootstrap Claude Code — creates .claude/, .avvarre/, and CLAUDE.md.
suggest_skills: Auto-detects package stack and downloads/declines community rules (detect/fetch/decline actions with .declined.json).
avvarre_garden: Audits the workspace persistent memory folders (.avvarre/) to detect context drift, conventions mismatch, and stalled task lists.
Long-Term Memory (8 tools):
Tool
Purpose
Key params
avvarre_memory_store
Save with dedup 5m DedupWindow+15m hash+Jaccard 0.7+cosine 0.92strength 0.1..10 (server.ts:573, store.ts:12)
Resources: avvarre exposes 21 MCP resources (one per language) at avvarre://rules/{language} so AI agents can query rule rationales directly.
⚙️ Configuration & Architecture Deep-Dive
⚠️ The Problem
Vibe coding is fast, but AI models quickly lose context:
The memory resets: Every new chat session starts from absolute zero. You spend precious time re-explaining the tech stack, directory paths, and code conventions.
Style guides are ignored: The AI writes code that runs but breaks project style guides—leading to inconsistent naming, undocumented functions, and spaghetti patterns.
Verification is manual: Linters run in your terminal after the fact, not during the AI's generation process. Errors are caught too late.
Tooling sprawl: You need different linters for different languages—ESLint, Ruff, Checkstyle, SwiftLint—or you can just use avvarre for all of them.
💡 The Solution
avvarre is an IDE-agnostic MCP server and agent plugin ecosystem that embeds directly into your AI workflows.
[!NOTE]
Grade F to Grade A: Analyzes and suggests clean style guide fixes in milliseconds.
Continuous Handoff: Dev A works Monday, Dev B pulls Tuesday—the AI immediately catches up on context.
Autopilot Remediation: Let the AI autonomously clean up its own violations before presenting them to you.
avvarre operates across 8 layers to lock down quality and context:
Layer 1: Persistent AI Memory (The Core Moat) — Creates a version-controlled .avvarre/ directory in your workspace storing state documents (context.md, conventions.md, tasks.md, session-log.md, history.json, and modular skills/) plus SQLite memory.db long-term store.
Layer 3: Rule-Based Linting Engine — Instant style guide analysis enforcing 732 Google Style Guide rules locally across 21 languages with zero API keys or cloud dependencies.
Layer 4: AI-Powered Deep Review — Catches semantic design issues (logical anti-patterns, leaky abstractions, or hard-to-maintain closures) using configured LLMs.
Layer 5: Autopilot Loop — Self-correction loop where the agent autonomously repairs code violations (fixing, checking, and validating) up to 15 times until hitting Grade A (90+).
Session Sync & Doc Gardening: Writes session-log.md when the agent exits/goes idle, runs automated context/conventions/tasks freshness audits, and displays warnings to prevent memory rot.
Layer 7: IDE Portability — One MCP server powers all major AI dev clients: Claude Code, OpenCode, Antigravity 2.0, VS Code + GitHub Copilot, Cursor, and Codex.
source_qualified & target_qualified: Connecting node references using the filePath::Class::method qualified-name scheme.
🛠️ High-Performance AST Extraction
The AST parsing engine (parser.ts) uses WebAssembly grammars (web-tree-sitter) loaded dynamically on-demand from tree-sitter-wasms. It supports 15 extensions: JavaScript, TypeScript (+ TSX), Python, Go, Java, C#, C++, Shell (Bash), Kotlin, Swift, Objective-C, Dart, HTML, CSS, and R — 13 with full AST (Dart currently falls back to File-level due to ABI 15 vs [email protected] range 13-14; R falls back until tree-sitter-r.wasm ships in tree-sitter-wasms).
Language-Accurate Extraction: Each language uses its verified grammar node types (probed empirically). Classes, functions, tests, imports, and inheritance chains are extracted per language's AST shape—not via regex.
Three Edge Types:CALLS (callee names stripped to bare identifiers for cross-file join), IMPORTS_FROM (module paths cleaned of quotes), and INHERITS (base class / interface names). TESTED_BY edges are synthesised post-indexing by updateTestedByEdges().
Namespace Scoping: A scopeStack maintains the filePath::Class::method hierarchy as the AST is walked depth-first.
Incremental Hashing Moat (On-Demand): On every PreToolUsehook-impact-warn + tool.execute.after (and avvarre_get_impact), the engine re-indexes only affected files before the CTE — hash-checked (<5ms if unchanged, <50ms if changed), 9s guard, removeFileData on delete, WASM fallback to read-only. Scaffold is time-boxed to 8s (remaining indexed lazily), and WASM grammars (tree-sitter-wasms 15 wasm) are bundled into every plugin hooks/graph/wasm/ (claude/cursor/antigravity/codex/awesome/opencode — 6 plugins, scripts/postbuild.cjs:43) so all 6 IDEs get full parse without a watcher.
📈 Change Risk Calculation Formula
When files are edited, avvarre calculates risk based on test coverage, security tags, and downstream calls:
The final risk score is normalized and clamped strictly between 0.0 and 1.0.
🔍 Recursive CTE Blast-Radius Query
avvarre executes a recursive Common Table Expression query up to a depth of 5 hops to trace caller dependencies:
WITH RECURSIVE impacted(node_qn, depth) AS (
SELECT qn, 0 FROM _impact_seeds
UNION
-- Forward callee traversal
SELECT n.qualified_name, i.depth + 1
FROM impacted i
JOIN edges e ON (e.source_qualified = i.node_qn OR i.node_qn LIKE '%::' || e.source_qualified)
JOIN nodes n ON (n.qualified_name = e.target_qualified OR n.qualified_name LIKE '%::' || e.target_qualified)
WHERE i.depth < 5
UNION
-- Backward caller traversal
SELECT e.source_qualified, i.depth + 1
FROM impacted i
JOIN edges e ON (e.target_qualified = i.node_qn OR i.node_qn LIKE '%::' || e.target_qualified)
WHERE i.depth < 5
)
SELECT DISTINCT node_qn, MIN(depth) AS min_depth
FROM impacted
GROUP BY node_qn LIMIT 200;
If downstream caller dependencies exist, the edit process halts and prompts a context warning.
🛡️ Language Rules & Grading Logic
Grading Scale
Grade A (90–100): Google-grade quality code.
Grade B (80–89): Minor style points only.
Grade C (70–79): Needs attention.
Grade D (60–69): Heavy style violations.
Grade F (0–59): Critical structural issues.
[!TIP]
Penalties are weighted by severity: critical = 15, high = 10, medium = 5, low = 2. Large files are dynamically dampened using log-normalization so they are not unfairly penalized.
Language Support (732 Rules)
Language
Rules
Language
Rules
Language
Rules
TypeScript
74
Dart
49
Shell
37
JavaScript
49
Python
46
C++
44
Kotlin
40
Objective-C
42
C#
37
Java
39
Go
33
Swift
35
R
36
Vimscript
19
Lisp
26
HTML
16
CSS
15
Markdown
17
JSON
16
XML
16
Angular
16
🔑 LLM Provider Configuration
avvarre is offline-first, but you can configure external LLM providers for semantic deep reviews:
skills/ — Modular feature guidelines and domain-specific rules.
scaffold_avvarre parameters (src/server.ts:280)
Param
Type
Description
workspaceRoot
string required
Absolute path to workspace root
projectName
string
Project name (auto from package.json)
description
string
One-line description
techStack
string
Languages, frameworks, databases
targetAudience
string
Who is the target user
keyFeatures
string[]
Initial tasks / key features
externalApis
string
External APIs or services used
namingConventions
string
Custom naming rules
maxFileLines
number
Max lines before warning (default 1500)
Instead of bloating context by feeding the AI your entire repository, avvarre dynamically loads only the relevant skill file for the active task (e.g., database_schema_rules.md, react_ui_guidelines.md).
📦 Monorepo Support
To enable monorepo support, set chat.useCustomizationsInParentRepositories to true in your VS Code settings. Place avvarre at the root:
monorepo/
├── awesome-copilot/ ← avvarre hooks, agent, skills, commands (VS Code)
├── cursor-plugin/ ← avvarre hooks, agent, skills, commands (Cursor)
├── .avvarre/ ← Shared project memory
└── packages/
├── frontend/ ← Open this folder — hooks still fire
└── backend/ ← Open this folder — hooks still fire
🔌 Manual Plugin Setup
If you prefer to configure integrations manually, use the following configurations:
Claude Code
Copy claude-plugin/ to your workspace and add it to .claude/settings.json:
{
"plugins": ["./claude-plugin"]
}
VS Code + GitHub Copilot
Copy awesome-copilot/ to your workspace and add this to your global VS Code settings:
You can automatically set up the Codex plugin using the installer (npx -y avvarre@latest install --codex). Alternatively, this repository includes a Codex plugin at plugins/avvarre and a repository marketplace at .agents/plugins/marketplace.json. Open the repository in the ChatGPT desktop app, restart it, select Avvarre Plugins, and install Avvarre. Review and trust the bundled hooks before they run.
For a Git-backed marketplace, add the repository with codex plugin marketplace add PralhadYadawad/avvarre, then install avvarre from the avvarre marketplace. Public availability uses the official plugin submission portal.
Antigravity 2.0 (IDE & CLI)
Copy antigravity-plugin/ to:
Workspace:.agents/plugins/avvarre
Global IDE:~/.gemini/config/plugins/avvarre
Global CLI:~/.gemini/antigravity-cli/plugins/avvarre
🤖 AI Review Agent (@avvarre-reviewer)
The @avvarre-reviewer agent acts as a virtual auditor inside your chat workspace:
Gathers context and runs avvarre_file on changed files.
Orders fixes sequentially (high severity first).
Modifies code, re-runs verification, and updates tasks.md dynamically on success.
💎 Strategic Moats
Token Optimization & Context Moat: Traditional code agents reload entire code files or subdirectories to understand impact, burning through context windows. avvarre solves this by indexing the project architecture in a local, fast database—loading only the necessary symbols when requested.
Offline First & Airgapped Compliance: The core linting engine, SQLite DB, and tree-sitter parser run 100% locally. There is no telemetry, external network requests, or cloud dependency.
Multi-IDE Handoff Sync: The .avvarre/ directory acts as a portable memory block. Dev A using Cursor and Dev B using Claude Code share the same session context, task states, and architecture guidelines.
Graceful Degradation Moat: The server never blocks the developer. If an LLM key is missing, it runs local regex checks. If a file is too large for the model, it auto-chunks. If the AST parser fails, it defaults back to file-level lint rules.
🎯 Key Use Cases
Continuous Handoff in Distributed Teams: When developers swap tasks, the AI reads the session-log.md and tasks.md to pick up exactly where the last agent left off—eliminating onboarding handoff friction.
AST-Guided Quality Gates (CI/CD): Run avvarre_pr in your PR pipeline or pre-commit hooks to verify that code changes do not decrease the overall repository quality score below a set threshold.
Blast-Radius Visual Warnings: During large refactors, the agent is immediately warned if modifying a shared method would break downstream endpoints, prompting it to write corresponding unit tests.
🎨 Design Philosophy
Zero configuration to start: Out-of-the-box linting runs locally in under 100ms. No cloud keys needed.
Graceful degradation: Gracefully falls back to regex analysis if LLM keys are absent, chunks files if too large, and never blocks code editing.
Bypass memory limits: Scopes rule-sets and tasks into modular skills, avoiding context window clutter.
Single Tool, Every Stack: Replaces fragmented quality chains with a single standard MCP engine.
🔍 Under the Hood
Hardened Tokenizer: The getCleanLines utility strips out comments and raw strings before rules execute. This eliminates false positives triggered by URLs in strings or notes in comments.
AST-Aware Chunker: Files exceeding LLM token capacities (~500 lines) are safely split at class/function AST boundaries using a parser-driven chunker (chunker.ts) across all 15 supported languages, reviewed individually per chunk, and merged with corrected line numbers. Falls back to line-based splitting if AST parsing is unavailable.
Direct Resources: Every language style guide exposes rules as a avvarre://rules/{language} resource endpoint for agents to query.
📝 The Compressed Task Protocol
AI agents communicate across sessions using a compact format inside tasks.md:
[x] Built user auth flow (steps: schema→routes→middleware→tests→docs)
[/] Refactoring payments (done: extract-service→add-types | next: update-routes→tests)
[ ] Add rate limiting to API endpoints
Agents parse these steps directly into their working memory context, resolving context drift during task handoffs.
🛣️ Roadmap & Contributing
We welcome contributions to expand rulesets, IDE plugins, and integrations.
अभी टूल सूची नहीं है। रिमोट सर्वर को पहले हेल्थ चेक के बाद सूची मिलती है।
FAQ
सवाल
Avvarre कैसे इंस्टॉल करें?
इस पेज पर Cursor, Claude Desktop, Claude Code या VS Code के लिए stdio कॉन्फ़िग कॉपी करें। यह पब्लिशर का इंस्टॉल इस्तेमाल करता है, PlugMCP प्रॉक्सी नहीं।
क्या Avvarre के लिए API key चाहिए?
इस रिकॉर्ड में कोई ज़रूरी एनवायरनमेंट वेरिएबल दर्ज नहीं है।
Avvarre कौन सा ट्रांसपोर्ट इस्तेमाल करता है?
Avvarre stdio पर लोकल चलता है।
Avvarre की पिछली जाँच कब हुई थी?
पिछली जाँच 2026-10-28 को हुई। AI context that survives the chat window. Persistent repo memory, impact analysis, and instant style audits in one command.