Ontwikkel een Windsurf AI-gestuurde Contextuele Code Navigatie
description
Met deze prompt kun je een slimme navigatieoplossing ontwerpen die het zoeken en begrijpen van complexe codebases versnelt. Het lost het probleem op van tijdrovend zoeken en contextverlies bij grote projecten en biedt een efficiëntere workflow dan traditionele zoekfuncties.
prompt
Help me bij het ontwikkelen van een AI-gestuurde contextuele code navigatie binnen Windsurf die me snel door complexe codebases leidt. Mijn softwareprojecttype: <voer het type softwareprojec ...
try_prompt
generate_helper
disclaimerOnPageApi
tags
ai_answers
provider: openai
model: gpt-4.1-nano
Natuurlijk! Hier zijn enkele stappen en aanbevelingen om een AI-gestuurde contextuele code-navigatie voor Windsurf te ontwikkelen, gericht op JavaScript en TypeScript, om je te helpen bij complexe codebases:
1. Analyseer je Codebase en Modules
- Gebruik statische analysetools (bijv. ESLint, TypeScript Language Service) om de structuur en afhankelijkheden te begrijpen.
- Bouw een module- en dependency-grafiek om overzicht te krijgen.
2. Implementatie van Contextuele AI-Componenten
- Integreer een NLP-model (zoals GPT-4 API) dat kan begrijpen en interpreteren wat je zoekt.
- Ontwikkel een interface waarmee je natuurlijke taalvragen kunt stellen over je code (bijv. "Waar wordt de login-functie aangeroepen?").
3. Contextbehoud en -verrijking
- Sla relevante context op tijdens je navigatie (bijv. huidige module, functie, afhankelijkheden).
- Gebruik deze context om gerichte zoekopdrachten te doen en je navigatie te verfijnen.
4. Automatisering en Zoekfuncties
- Implementeer zoekfuncties die, op basis van je vraag en context, automatisch relevante codefragmenten, functies of modules ophalen.
- Maak gebruik van code-indexeringstools zoals Sourcegraph of een aangepaste index met Algolia.
5. Visualisatie van Code en Afhankelijkheden
- Voeg visuele tools toe die afhankelijkheden en modulestructuren weergeven, zodat je snel overzicht krijgt.
6. Integratie in je IDE
- Bouw een plugin of extensie voor populaire IDE's (VSCode, WebStorm) die AI-gestuurde navigatie ondersteunt.
- Zorg dat de AI-vragen en aanbevelingen direct in je ontwikkelomgeving verschijnen.
7. Continuerende Verbetering
- Verzamel feedback van gebruikers (jezelf) om de AI-ondersteuning te verbeteren.
- Pas de AI-modellen en interface aan op basis van je ervaring en nieuwe uitdagingen.
8. Veiligheid en Privacy
- Zorg dat gevoelige code niet onbedoeld gedeeld wordt bij gebruik van externe AI-diensten.
- Overweeg lokale AI-modellen of beveiligde communicatiekanalen.
Kort samengevat: combineer code-analyse, NLP voor natuurlijke taalvragen, contextmanagement en visuele hulpmiddelen. Hiermee krijg je een krachtige, AI-gestuurde navigatie die je snel door complexe en grote codebases leidt, zonder de context te verliezen.
Wil je dat ik je help met het opzetten van een specifieke tool of codevoorbeeld voor een van deze stappen?
provider: deepseek
model: deepseek-chat
Zeker, ik help je graag bij het ontwikkelen van een AI-gestuurde contextuele code navigatie voor Windsurf. Hier is een praktisch plan specifiek afgestemd op jouw webapplicatieproject met JavaScript/TypeScript:
## Kernfunctionaliteiten voor contextuele navigatie
### 1. **Intelligente Context Tracking**
```typescript
interface NavigationContext {
currentModule: string;
relatedComponents: string[];
dataFlow: string[];
recentFiles: string[];
dependencyTree: DependencyNode[];
}
```
### 2. **Module-Relatie Mapping**
- Automatische detectie van import/export relaties
- Visualisatie van component-hiërarchieën
- Real-time updates bij code wijzigingen
### 3. **AI-Gestuurde Snelkoppelingen**
```javascript
// Voorbeeld commando's:
// "toon alle components die UserProfile gebruiken"
// "navigeer naar de parent component van dit formulier"
// "toon waar deze API call wordt aangeroepen"
```
## Implementatiestappen
### Stap 1: Context Verzameling
```typescript
class ContextCollector {
async collectFileRelations(filePath: string): Promise<FileRelation[]> {
// Analyseer imports, exports en function calls
}
async buildDependencyGraph(): Promise<DependencyGraph> {
// Bouw een real-time dependency graph
}
}
```
### Stap 2: AI-Powered Navigatie
```typescript
class AINavigationEngine {
async suggestNavigation(target: string, context: NavigationContext): Promise<NavigationSuggestion[]> {
// Gebruik embeddings voor semantische zoekopdrachten
// Combineer met structurele analyse
}
async predictNextFiles(currentWork: string): Promise<string[]> {
// Voorspel welke bestanden relevant zijn gebaseerd op huidige context
}
}
```
### Stap 3: Visual Feedback Integratie
- Breadcrumb trail met contextuele hints
- Kleurcodering voor module-types
- Hotkeys voor snelle context-switching
## Windsurf-specifieke features
### 1. **Contextuele Breadcrumbs**
```
Home > UserManagement > UserProfile > EditForm > Validation
[🔄] [📊] [🔗] // Snelle actie knoppen per niveau
```
### 2. **Semantische Zoekopdrachten**
```javascript
// Voorbeelden:
"zoek components met form validation"
"toon alle API calls naar /users"
"find files using Redux store moduleX"
```
### 3. **Workflow-based Navigatie**
```typescript
interface WorkflowTemplate {
name: "feature_development" | "bug_fixing" | "code_review";
suggestedFiles: string[];
commonPatterns: NavigationPattern[];
}
```
## Technische implementatie tips
### Voor JavaScript/TypeScript projecten:
```typescript
// Gebruik TypeScript compiler API voor betere analyse
import * as ts from "typescript";
// Implementeer AST parsing voor accurate dependency detection
function extractDependencies(sourceFile: ts.SourceFile): string[] {
// Analyseer imports, requires en dynamic imports
}
```
### Performance optimalisaties:
- Incrementele parsing bij bestandswijzigingen
- Caching van dependency graphs
- Background analysis voor grote projecten
## Aanbevolen integraties
1. **VS Code Extension API** voor seamless integratie
2. **Git integratie** voor context-aware navigation based on changes
3. **Package.json analysis** voor module boundary detection
Wil je dat ik dieper inga op een specifiek onderdeel, zoals de AI-algoritmes voor contextvoorspelling of de technische implementatie van de dependency graph?