AppMap

Captures real-time execution traces of running code including HTTP calls, SQL queries, exceptions, I/O operations, and data flow, then visualizes this data as sequence diagrams, flame graphs, dependency maps, and trace views. Works by instrumenting code execution within the VS Code environment without requiring code modifications, storing AppMap data snapshots that feed into AI analysis. The extension integrates with the debugger/test runner to passively record application behavior during development and testing sessions.

Provides AI-generated explanations of code behavior by combining static code analysis with captured runtime execution traces. Activated via the `@explain` chat mode, this capability uses the Navie AI assistant (after authentication) to answer questions about what code does, why it behaves a certain way, and what data flows through it. The AI synthesizes information from the current file, project scope, git branch context, and recorded AppMap execution data to generate contextually accurate explanations.

Identifies security vulnerabilities and issues in code through the `@review` mode and general code analysis, leveraging the LLM's security knowledge combined with codebase context. The AI analyzes code patterns, dependencies, and data flows to detect common vulnerabilities such as injection attacks, insecure authentication, exposed credentials, and unsafe data handling. Results are presented as actionable security findings with context about where issues occur in the codebase.

Identifies performance bottlenecks and optimization opportunities by analyzing recorded execution traces (flame graphs, execution timings) combined with code analysis. The AI examines where code spends the most time, identifies inefficient patterns, and suggests optimizations. This capability is enhanced when AppMap execution traces are available, providing concrete data about actual performance characteristics rather than theoretical analysis.

Evaluates code maintainability and identifies technical debt through code analysis and review workflows. The AI examines code complexity, duplication, adherence to design patterns, test coverage, and documentation completeness to assess maintainability. Technical debt is identified through patterns like overly complex functions, missing abstractions, inconsistent naming, and insufficient testing. Results are presented with specific recommendations for improvement.

Manages user authentication and workspace context to enable personalized AI assistance. Users can sign in via email, GitHub, or GitLab credentials to unlock the Navie AI assistant and access personalized features. The extension maintains workspace context including the current file, project scope, git branch information, and recorded AppMap traces. Authentication state and workspace context are used to customize AI responses and enable features like branch-aware code review.

Performs AI-driven code reviews by analyzing differences between the current branch and base branch, using the `@review` chat mode to identify security issues, maintainability concerns, logic errors, and performance problems. The extension accesses git context to compare code changes and applies the selected LLM to generate review feedback. Reviews can be enhanced with runtime execution traces if AppMap data has been recorded for the changed code.

Generates detailed implementation plans for coding tasks using the `@plan` chat mode, which breaks down requirements into actionable steps. The AI analyzes the current codebase context, project structure, and existing patterns to create plans that align with the application's architecture. Plans are generated as structured text that developers can follow sequentially to implement features or refactor code.

Generates code snippets and implementations using the `@generate` chat mode, which synthesizes new code based on the current codebase context, existing patterns, and project architecture. The AI produces patch-ready code that developers can directly integrate into their files. Generation can be enhanced with runtime execution traces to ensure generated code aligns with actual application behavior and data flows.

Generates unit and integration test cases using the `@test` chat mode, which analyzes the code structure and existing test patterns to create tests that align with the project's testing conventions. The AI can generate tests based on static code analysis or enhanced with runtime execution traces to create tests that cover observed code paths and data flows. Generated tests are provided as patch-ready code.

Generates Mermaid diagrams (sequence diagrams, UML diagrams, dependency graphs) using the `@diagram` chat mode, which visualizes code structure, architecture, and data flows. The AI can generate diagrams from static code analysis or enhanced with runtime execution traces to show actual application behavior. Generated diagrams are rendered in the Mermaid Live Editor and can be exported or embedded in documentation.

Provides a unified chat interface that supports multiple LLM providers including OpenAI, Anthropic Claude, Google Gemini, GitHub Copilot, Mistral, Mixtral, Ollama (local), and AppMap's built-in endpoint. Users can configure their preferred LLM by providing API keys, and the extension routes all chat queries through the selected provider. The architecture abstracts provider-specific APIs behind a common chat interface, allowing seamless switching between models.

Implements a chat-based interaction model where users invoke different AI capabilities by prefixing queries with `@` commands (`@explain`, `@plan`, `@generate`, `@test`, `@diagram`, `@review`). Each mode routes the query to a specialized AI workflow optimized for that task. The chat interface maintains conversation history and context across multiple turns, allowing follow-up questions and iterative refinement of results.

Automatically injects codebase context into LLM queries by analyzing the current file, project scope, git branch information, and optionally recorded AppMap execution traces. The extension builds a context representation that includes code structure, existing patterns, dependencies, and runtime behavior, then includes this context in prompts sent to the LLM. This enables AI responses that are tailored to the specific codebase rather than generic.