javi-forge 0.1.0

package/ai-config/skills/workflow/ide-plugins/SKILL.md

@@ -0,0 +1,277 @@
+---
+name: ide-plugins
+description: >
+  IDE plugin concepts. Extension points, Language Server Protocol, code completion, refactoring.
+  Trigger: IDE plugin, IntelliJ, VSCode extension, Eclipse plugin, LSP
+tools:
+  - Read
+  - Write
+  - Edit
+  - Grep
+metadata:
+  author: apigen-team
+  version: "1.0"
+  tags: [ide, plugins, extensions, developer-tools]
+  scope: ["**/ide-plugins/**"]
+---
+
+# IDE Plugin Concepts
+
+## Plugin Architectures
+
+### IntelliJ Platform
+```
+Components:
+- Actions: Menu items, toolbar buttons
+- Services: Application/Project-level singletons
+- Extensions: Plugin extension points
+- PSI: Program Structure Interface (AST)
+- VFS: Virtual File System
+
+Lifecycle:
+1. Plugin loading (lazy)
+2. Component initialization
+3. Extension registration
+4. User interaction
+5. Disposal
+```
+
+### VSCode Extensions
+```
+Components:
+- Activation Events: When to load
+- Commands: User actions
+- Views: Custom UI panels
+- Language Support: Syntax, completion
+- Webview: Custom HTML panels
+
+API Types:
+- VS Code API (editor, window, workspace)
+- Language Server Protocol
+- Debug Adapter Protocol
+```
+
+### Eclipse Plugins
+```
+Components:
+- Extension Points: Plugin hooks
+- Views: UI panels
+- Editors: File editors
+- Nature/Builder: Project configuration
+- Commands: Actions
+
+OSGi bundles for modular architecture
+```
+
+## Language Server Protocol (LSP)
+
+```
+Standard protocol for IDE features:
+
+Client (IDE) ←→ Server (Language-specific)
+
+Features:
+- Completion
+- Hover
+- Go to Definition
+- Find References
+- Rename
+- Diagnostics
+- Code Actions
+- Formatting
+
+Benefits:
+- One server, multiple IDEs
+- Language-agnostic
+- Separate processes
+```
+
+### LSP Message Types
+```json
+// Request: Client → Server
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "method": "textDocument/completion",
+  "params": {
+    "textDocument": {"uri": "file:///path/to/file.java"},
+    "position": {"line": 10, "character": 5}
+  }
+}
+
+// Response: Server → Client
+{
+  "jsonrpc": "2.0",
+  "id": 1,
+  "result": {
+    "items": [
+      {"label": "toString", "kind": 2, "detail": "String"},
+      {"label": "equals", "kind": 2, "detail": "boolean"}
+    ]
+  }
+}
+
+// Notification: Server → Client (no response)
+{
+  "jsonrpc": "2.0",
+  "method": "textDocument/publishDiagnostics",
+  "params": {
+    "uri": "file:///path/to/file.java",
+    "diagnostics": [
+      {"range": {...}, "message": "Unused variable", "severity": 2}
+    ]
+  }
+}
+```
+
+## Common Plugin Features
+
+### Code Completion
+```
+Types:
+- Keyword completion
+- Symbol completion (classes, methods)
+- Snippet completion
+- AI-powered completion
+
+Trigger:
+- After typing characters
+- On explicit request (Ctrl+Space)
+- After specific characters (., ::)
+```
+
+### Code Navigation
+```
+Features:
+- Go to Definition
+- Go to Type Definition
+- Go to Implementation
+- Find All References
+- Call Hierarchy
+- Type Hierarchy
+```
+
+### Quick Fixes / Code Actions
+```
+Triggered by:
+- Diagnostics (errors, warnings)
+- Cursor position
+- Selection
+
+Examples:
+- Add missing import
+- Implement interface methods
+- Extract method
+- Rename symbol
+- Convert to lambda
+```
+
+### Live Templates / Snippets
+```
+Template:
+  trigger: "sout"
+  body: "System.out.println($1);"
+
+Variables:
+- $1, $2: Tab stops
+- ${1:default}: Default value
+- ${TM_FILENAME}: Built-in variables
+```
+
+### Inspections / Linting
+```
+Analyze code for:
+- Errors: Syntax, type errors
+- Warnings: Code smells
+- Info: Suggestions
+
+Display:
+- Inline highlighting
+- Problems panel
+- Gutter icons
+```
+
+## APiGen Plugin Features
+
+### Entity Generation
+```
+Right-click on SQL file:
+  Generate > APiGen Entity
+
+Wizard:
+1. Select tables
+2. Configure options (HATEOAS, soft delete)
+3. Generate files
+```
+
+### Code Templates
+```
+Live templates for APiGen:
+- apigen.controller: BaseController template
+- apigen.service: BaseService template
+- apigen.entity: Entity with auditing
+- apigen.dto: DTO with validation
+```
+
+### Configuration Assistant
+```
+Smart completion for:
+- application.yml (app.* properties)
+- Spring Security configuration
+- Database settings
+
+Validation:
+- Required properties
+- Type checking
+- Reference resolution
+```
+
+## Development Best Practices
+
+```
+Performance:
+✅ Lazy initialization
+✅ Background processing
+✅ Incremental updates
+✅ Caching results
+❌ Blocking UI thread
+❌ Heavy startup tasks
+
+UX:
+✅ Progressive disclosure
+✅ Keyboard shortcuts
+✅ Consistent icons
+✅ Clear error messages
+❌ Modal dialogs (blocking)
+
+Compatibility:
+✅ Support multiple IDE versions
+✅ Graceful degradation
+✅ Platform-specific features
+✅ Thorough testing
+```
+
+## Distribution
+
+```
+IntelliJ:
+- JetBrains Marketplace
+- Plugin repository URL
+- Manual installation
+
+VSCode:
+- VS Code Marketplace
+- VSIX file
+
+Eclipse:
+- Eclipse Marketplace
+- Update site URL
+- Dropins folder
+```
+
+## Related Skills
+
+- `ide-plugins-intellij`: IntelliJ plugin implementation
+- `apigen-architecture`: Overall system architecture
+
+

package/ai-config/skills/workflow/ide-plugins-intellij/SKILL.md

@@ -0,0 +1,401 @@
+---
+name: ide-plugins-intellij
+description: >
+  IntelliJ Platform plugin development. Actions, services, PSI, code generation.
+  Trigger: apigen-ide-plugins, IntelliJ plugin, PSI, AnAction, @Service
+tools:
+  - Read
+  - Write
+  - Edit
+  - Bash
+  - Grep
+metadata:
+  author: apigen-team
+  version: "1.0"
+  tags: [ide, intellij, plugin, java]
+  scope: ["apigen-ide-plugins/**"]
+---
+
+# IntelliJ Plugin Development (apigen-ide-plugins)
+
+## Project Setup
+
+### build.gradle.kts
+```kotlin
+plugins {
+    id("java")
+    id("org.jetbrains.intellij.platform") version "2.2.0"
+}
+
+intellijPlatform {
+    pluginConfiguration {
+        name = "APiGen Support"
+        version = "1.0.0"
+        ideaVersion {
+            sinceBuild = "243"
+            untilBuild = "243.*"
+        }
+    }
+}
+
+repositories {
+    mavenCentral()
+    intellijPlatform {
+        defaultRepositories()
+    }
+}
+
+dependencies {
+    intellijPlatform {
+        intellijIdeaCommunity("2024.3")
+        bundledPlugin("com.intellij.java")
+    }
+}
+```
+
+### plugin.xml
+```xml
+<idea-plugin>
+    <id>com.jnzader.apigen</id>
+    <name>APiGen Support</name>
+    <vendor>APiGen Team</vendor>
+
+    <depends>com.intellij.modules.platform</depends>
+    <depends>com.intellij.modules.java</depends>
+
+    <extensions defaultExtensionNs="com.intellij">
+        <!-- File templates -->
+        <internalFileTemplate name="APiGen Controller"/>
+        <internalFileTemplate name="APiGen Service"/>
+        <internalFileTemplate name="APiGen Entity"/>
+
+        <!-- Completion contributor -->
+        <completion.contributor
+            language="yaml"
+            implementationClass="com.jnzader.apigen.ide.completion.YamlCompletionContributor"/>
+
+        <!-- Annotator for validation -->
+        <annotator
+            language="JAVA"
+            implementationClass="com.jnzader.apigen.ide.annotator.ApigenAnnotator"/>
+
+        <!-- Project service -->
+        <projectService
+            serviceImplementation="com.jnzader.apigen.ide.service.ApigenProjectService"/>
+
+        <!-- Tool window -->
+        <toolWindow
+            id="APiGen"
+            anchor="right"
+            factoryClass="com.jnzader.apigen.ide.toolwindow.ApigenToolWindowFactory"/>
+    </extensions>
+
+    <actions>
+        <group id="APiGen.GenerateGroup" text="APiGen" popup="true">
+            <add-to-group group-id="GenerateGroup" anchor="last"/>
+            <action id="APiGen.GenerateEntity"
+                    class="com.jnzader.apigen.ide.action.GenerateEntityAction"
+                    text="Entity from Table"
+                    description="Generate entity from database table"/>
+            <action id="APiGen.GenerateCrud"
+                    class="com.jnzader.apigen.ide.action.GenerateCrudAction"
+                    text="CRUD Stack"
+                    description="Generate controller, service, repository"/>
+        </group>
+    </actions>
+</idea-plugin>
+```
+
+## Actions
+
+```java
+public class GenerateEntityAction extends AnAction {
+
+    @Override
+    public void actionPerformed(@NotNull AnActionEvent e) {
+        Project project = e.getProject();
+        if (project == null) return;
+
+        // Show dialog
+        GenerateEntityDialog dialog = new GenerateEntityDialog(project);
+        if (!dialog.showAndGet()) return;
+
+        // Generate files
+        WriteCommandAction.runWriteCommandAction(project, () -> {
+            EntityGeneratorService generator =
+                project.getService(EntityGeneratorService.class);
+
+            generator.generateEntity(dialog.getTableDefinition(),
+                                      dialog.getOptions());
+        });
+    }
+
+    @Override
+    public void update(@NotNull AnActionEvent e) {
+        // Only enable in Java project
+        Project project = e.getProject();
+        boolean enabled = project != null &&
+            ProjectRootManager.getInstance(project).getProjectSdk() != null;
+        e.getPresentation().setEnabledAndVisible(enabled);
+    }
+
+    @Override
+    public @NotNull ActionUpdateThread getActionUpdateThread() {
+        return ActionUpdateThread.BGT;
+    }
+}
+```
+
+## Services
+
+```java
+@Service(Service.Level.PROJECT)
+public final class ApigenProjectService {
+
+    private final Project project;
+    private final Map<String, ApigenModule> modules = new HashMap<>();
+
+    public ApigenProjectService(Project project) {
+        this.project = project;
+        loadConfiguration();
+    }
+
+    private void loadConfiguration() {
+        // Find apigen configuration files
+        VirtualFile baseDir = project.getBaseDir();
+        VirtualFile configFile = baseDir.findFileByRelativePath(
+            "src/main/resources/application.yml");
+
+        if (configFile != null) {
+            parseConfiguration(configFile);
+        }
+    }
+
+    public boolean isApigenProject() {
+        // Check for apigen dependencies in build.gradle
+        return modules.containsKey("apigen-core");
+    }
+
+    public List<String> getConfiguredEntities() {
+        return modules.values().stream()
+            .flatMap(m -> m.getEntities().stream())
+            .map(EntityConfig::getName)
+            .toList();
+    }
+}
+```
+
+## Code Completion
+
+```java
+public class YamlCompletionContributor extends CompletionContributor {
+
+    public YamlCompletionContributor() {
+        // Completion for app.* properties
+        extend(CompletionType.BASIC,
+            PlatformPatterns.psiElement()
+                .inside(YAMLKeyValue.class)
+                .withLanguage(YAMLLanguage.INSTANCE),
+            new ApigenYamlCompletionProvider());
+    }
+
+    private static class ApigenYamlCompletionProvider extends CompletionProvider<CompletionParameters> {
+
+        @Override
+        protected void addCompletions(@NotNull CompletionParameters parameters,
+                                       @NotNull ProcessingContext context,
+                                       @NotNull CompletionResultSet result) {
+
+            PsiElement position = parameters.getPosition();
+            String prefix = getPrefix(position);
+
+            if (prefix.startsWith("app.")) {
+                // Add apigen-core properties
+                addCoreProperties(result);
+            } else if (prefix.startsWith("apigen.security.")) {
+                // Add security properties
+                addSecurityProperties(result);
+            }
+        }
+
+        private void addCoreProperties(CompletionResultSet result) {
+            result.addElement(LookupElementBuilder.create("app.cache.enabled")
+                .withTypeText("boolean")
+                .withTailText(" = true", true));
+
+            result.addElement(LookupElementBuilder.create("app.pagination.default-size")
+                .withTypeText("int")
+                .withTailText(" = 20", true));
+
+            result.addElement(LookupElementBuilder.create("app.rate-limit.enabled")
+                .withTypeText("boolean")
+                .withTailText(" = false", true));
+        }
+    }
+}
+```
+
+## PSI Annotator
+
+```java
+public class ApigenAnnotator implements Annotator {
+
+    @Override
+    public void annotate(@NotNull PsiElement element, @NotNull AnnotationHolder holder) {
+        if (!(element instanceof PsiClass psiClass)) return;
+
+        // Check if extends BaseService
+        PsiClass superClass = psiClass.getSuperClass();
+        if (superClass != null && "BaseService".equals(superClass.getName())) {
+            checkServiceImplementation(psiClass, holder);
+        }
+
+        // Check Entity annotations
+        if (hasAnnotation(psiClass, "jakarta.persistence.Entity")) {
+            checkEntityConfiguration(psiClass, holder);
+        }
+    }
+
+    private void checkServiceImplementation(PsiClass psiClass, AnnotationHolder holder) {
+        // Check for required methods
+        if (findMethod(psiClass, "getRepository") == null) {
+            holder.newAnnotation(HighlightSeverity.WARNING,
+                "BaseService subclass should implement getRepository()")
+                .range(psiClass.getNameIdentifier())
+                .withFix(new ImplementGetRepositoryFix(psiClass))
+                .create();
+        }
+    }
+
+    private void checkEntityConfiguration(PsiClass psiClass, AnnotationHolder holder) {
+        // Check for ID field
+        boolean hasId = Arrays.stream(psiClass.getFields())
+            .anyMatch(f -> hasAnnotation(f, "jakarta.persistence.Id"));
+
+        if (!hasId) {
+            holder.newAnnotation(HighlightSeverity.ERROR,
+                "Entity must have an @Id field")
+                .range(psiClass.getNameIdentifier())
+                .create();
+        }
+    }
+}
+```
+
+## Quick Fixes
+
+```java
+public class ImplementGetRepositoryFix implements LocalQuickFix {
+
+    private final PsiClass psiClass;
+
+    @Override
+    public @NotNull String getFamilyName() {
+        return "Implement getRepository() method";
+    }
+
+    @Override
+    public void applyFix(@NotNull Project project, @NotNull ProblemDescriptor descriptor) {
+        WriteCommandAction.runWriteCommandAction(project, () -> {
+            PsiElementFactory factory = JavaPsiFacade.getElementFactory(project);
+
+            // Find entity type from generic parameter
+            String entityType = extractEntityType(psiClass);
+
+            String methodText = String.format("""
+                @Override
+                protected JpaRepository<%s, UUID> getRepository() {
+                    return repository;
+                }
+                """, entityType);
+
+            PsiMethod method = factory.createMethodFromText(methodText, psiClass);
+            psiClass.add(method);
+
+            // Format and optimize imports
+            CodeStyleManager.getInstance(project).reformat(method);
+            JavaCodeStyleManager.getInstance(project).optimizeImports(psiClass.getContainingFile());
+        });
+    }
+}
+```
+
+## Tool Window
+
+```java
+public class ApigenToolWindowFactory implements ToolWindowFactory {
+
+    @Override
+    public void createToolWindowContent(@NotNull Project project, @NotNull ToolWindow toolWindow) {
+        ApigenToolWindowPanel panel = new ApigenToolWindowPanel(project);
+        ContentFactory contentFactory = ContentFactory.getInstance();
+        Content content = contentFactory.createContent(panel, "Entities", false);
+        toolWindow.getContentManager().addContent(content);
+    }
+}
+
+public class ApigenToolWindowPanel extends SimpleToolWindowPanel {
+
+    private final Tree entityTree;
+
+    public ApigenToolWindowPanel(Project project) {
+        super(true, true);
+
+        ApigenProjectService service = project.getService(ApigenProjectService.class);
+
+        // Build tree model
+        DefaultMutableTreeNode root = new DefaultMutableTreeNode("Entities");
+        for (String entity : service.getConfiguredEntities()) {
+            root.add(new DefaultMutableTreeNode(entity));
+        }
+
+        entityTree = new Tree(new DefaultTreeModel(root));
+        setContent(ScrollPaneFactory.createScrollPane(entityTree));
+
+        // Add toolbar
+        ActionToolbar toolbar = ActionManager.getInstance()
+            .createActionToolbar("ApigenToolbar", createActionGroup(), true);
+        toolbar.setTargetComponent(this);
+        setToolbar(toolbar.getComponent());
+    }
+
+    private ActionGroup createActionGroup() {
+        DefaultActionGroup group = new DefaultActionGroup();
+        group.add(new RefreshAction());
+        group.add(new GenerateAction());
+        return group;
+    }
+}
+```
+
+## File Templates
+
+```java
+// fileTemplates/internal/APiGen Controller.java.ft
+#if (${PACKAGE_NAME} && ${PACKAGE_NAME} != "")package ${PACKAGE_NAME};#end
+
+import com.jnzader.apigen.core.web.BaseController;
+import org.springframework.web.bind.annotation.*;
+
+@RestController
+@RequestMapping("/api/${ENTITY_PATH}")
+public class ${NAME} extends BaseController<${ENTITY}, ${DTO}, ${ID_TYPE}> {
+
+    private final ${SERVICE} service;
+
+    public ${NAME}(${SERVICE} service) {
+        this.service = service;
+    }
+
+    @Override
+    protected BaseService<${ENTITY}, ${DTO}, ${ID_TYPE}> getService() {
+        return service;
+    }
+}
+```
+
+## Testing
+
+```java
+public class ApigenAnnotatorTest extends LightJavaCodeInsightFixtureTestCase {
+```