@nockdev/awf 6.2.0 → 6.2.1

package/.agent/skills/tooling/ide-extension/SKILL.md

@@ -0,0 +1,108 @@
+# IDE Extension Development — VS Code • JetBrains • Neovim
+
+> Multi-IDE extension development  
+> LSP • DAP • Webviews • Plugin SDKs
+
+---
+
+## Khi Nào Dùng
+
+- Phát triển VS Code extension
+- Build JetBrains plugin (IntelliJ, WebStorm, etc.)
+- Viết Neovim plugin (Lua)
+- Implement Language Server (LSP) cho ngôn ngữ mới
+
+## VS Code Extension Architecture
+
+```
+┌────────────────────────────────────────┐
+│ VS Code (Electron)                     │
+│  ┌──────────────┐  ┌────────────────┐ │
+│  │ Main Process │  │ Extension Host │ │ ← Isolated process
+│  │ (UI, Window) │  │  ┌──────────┐  │ │
+│  │              │  │  │ Your Ext │  │ │
+│  │              │  │  └──────────┘  │ │
+│  └──────────────┘  └────────────────┘ │
+│                    ┌────────────────┐  │
+│                    │   Webview      │  │ ← Sandboxed iframe
+│                    │ (React/Vue)   │  │
+│                    └────────────────┘  │
+└────────────────────────────────────────┘
+```
+
+### package.json Contribution Points
+
+```json
+{
+  "contributes": {
+    "commands": [{ "command": "ext.doSomething", "title": "Do Something" }],
+    "keybindings": [{ "command": "ext.doSomething", "key": "ctrl+shift+p" }],
+    "views": { "explorer": [{ "id": "myView", "name": "My View" }] },
+    "configuration": { "properties": { "ext.setting": { "type": "boolean" } } }
+  },
+  "activationEvents": ["onLanguage:typescript", "onCommand:ext.doSomething"]
+}
+```
+
+### Extension Lifecycle
+
+```typescript
+export function activate(context: vscode.ExtensionContext) {
+  // Register commands, providers, etc.
+  const disposable = vscode.commands.registerCommand("ext.doSomething", () => { ... });
+  context.subscriptions.push(disposable);
+}
+export function deactivate() { /* cleanup */ }
+```
+
+## Language Server Protocol (LSP)
+
+### When to Use
+
+- Code completion, go-to-definition, hover info
+- Diagnostics (errors/warnings)
+- Code actions (quick fixes, refactoring)
+- Supporting same language across multiple IDEs
+
+### Server Setup
+
+```typescript
+const connection = createConnection(ProtocoLConnection);
+const documents = new TextDocuments(TextDocument);
+connection.onInitialize((_params) => ({
+  capabilities: {
+    completionProvider: { triggerCharacters: ["."] },
+    hoverProvider: true,
+    definitionProvider: true,
+  },
+}));
+documents.listen(connection);
+connection.listen();
+```
+
+## JetBrains Plugin (Quick Reference)
+
+- **plugin.xml**: Extension points, actions, services
+- **PSI**: Program Structure Interface for code analysis
+- **Services**: Application/project/module-level singletons
+- **Remote Dev**: Ensure backend compatibility
+
+## Neovim Plugin (Quick Reference)
+
+- **Lua**: `lua/pluginname/init.lua` entry point
+- **Setup**: `require("pluginname").setup({ ... })` pattern
+- **LSP**: `vim.lsp.start({ name, cmd, root_dir })` native LSP
+- **lazy.nvim**: Modern plugin manager
+
+## Common Traps
+
+| Trap                | Fix                                     |
+| ------------------- | --------------------------------------- |
+| Extension slows IDE | Lazy activation, async operations       |
+| Webview state lost  | `getState`/`setState` persistence       |
+| LSP not connecting  | Check stdio/IPC transport, log stderr   |
+| Memory leaks        | Dispose subscriptions in `deactivate()` |
+
+---
+
+_DOMYH Awesome Code • IDE Extension Skill v1.0.0_

package/.agent/skills/tooling/ide-extension/data/jetbrains-patterns.yaml

@@ -0,0 +1,118 @@
+# JetBrains Plugin Patterns — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: JB-001
+    name: Plugin Structure
+    category: setup
+    description: JetBrains IntelliJ Plugin SDK structure.
+    text: |
+      Key files:
+      - plugin.xml: Extension points, actions, services
+      - build.gradle.kts: Gradle IntelliJ Plugin
+
+      Key concepts:
+      - Extension Points: Register plugin functionality  
+      - Actions: User-triggered operations (menus, toolbar)
+      - Services: Application/project/module-level singletons
+      - PSI: Program Structure Interface (AST)
+    example: |
+      // plugin.xml
+      <idea-plugin>
+        <id>com.example.myplugin</id>
+        <name>My Plugin</name>
+        <depends>com.intellij.modules.platform</depends>
+        <extensions defaultExtensionNs="com.intellij">
+          <toolWindow id="MyWindow" factoryClass="com.example.MyToolWindowFactory"/>
+        </extensions>
+        <actions>
+          <action id="MyAction" class="com.example.MyAction" text="Do Something"/>
+        </actions>
+      </idea-plugin>
+
+  - id: JB-002
+    name: PSI Tree Traversal
+    category: analysis
+    description: |
+      Program Structure Interface for code analysis.
+    text: |
+      PSI provides AST-like tree for all supported languages.
+      Use PsiTreeUtil for traversal, PsiElementVisitor for walking.
+    example: |
+      // Kotlin
+      class MyInspection : LocalInspectionTool() {
+        override fun buildVisitor(holder: ProblemsHolder, isOnTheFly: Boolean): PsiElementVisitor {
+          return object : PsiElementVisitor() {
+            override fun visitElement(element: PsiElement) {
+              if (element is PsiMethod && element.name.startsWith("_")) {
+                holder.registerProblem(element, "Methods should not start with underscore")
+              }
+            }
+          }
+        }
+      }
+
+  - id: JB-003
+    name: Action System
+    category: ui
+    description: Register actions for menus, toolbar, shortcuts.
+    example: |
+      // Kotlin
+      class MyAction : AnAction("My Action") {
+        override fun actionPerformed(e: AnActionEvent) {
+          val project = e.project ?: return
+          val editor = e.getData(CommonDataKeys.EDITOR) ?: return
+          // perform action
+          Messages.showInfoMessage(project, "Hello!", "My Plugin")
+        }
+        override fun update(e: AnActionEvent) {
+          e.presentation.isEnabled = e.project != null
+        }
+      }
+
+  - id: JB-004
+    name: Service Pattern
+    category: architecture
+    description: |
+      Application/project-level singleton services.
+    text: |
+      Service levels:
+      - Application: Shared across all projects
+      - Project: One per open project  
+      - Module: One per module
+
+      Register in plugin.xml or use @Service annotation (2023+).
+    example: |
+      @Service(Service.Level.PROJECT)
+      class MyProjectService(private val project: Project) {
+        fun analyze(): List<Finding> { ... }
+        companion object {
+          fun getInstance(project: Project) = project.service<MyProjectService>()
+        }
+      }
+
+  - id: JB-005
+    name: Tool Window
+    category: ui
+    description: Custom panels in IDE (bottom/side panels).
+    example: |
+      class MyToolWindowFactory : ToolWindowFactory {
+        override fun createToolWindowContent(project: Project, toolWindow: ToolWindow) {
+          val panel = JPanel(BorderLayout())
+          panel.add(JLabel("Hello from plugin!"), BorderLayout.CENTER)
+          val content = ContentFactory.getInstance().createContent(panel, "My Tab", false)
+          toolWindow.contentManager.addContent(content)
+        }
+      }
+
+  - id: JB-006
+    name: Remote Dev Compatibility
+    category: architecture
+    description: |
+      Ensure plugin works with JetBrains Remote Development.
+    text: |
+      Rules for remote dev compatibility:
+      - Split frontend (UI) and backend (analysis) logic
+      - Use RemoteRobot for UI testing
+      - Avoid java.awt.* directly for headless backend
+      - Mark services with correct level (Project = backend, Application = mixed)

package/.agent/skills/tooling/ide-extension/data/lsp-patterns.yaml

@@ -0,0 +1,126 @@
+# Language Server Protocol Patterns — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: LSP-001
+    name: Server Initialization
+    category: setup
+    description: LSP server setup with capabilities negotiation.
+    text: |
+      Server declares capabilities during initialize handshake.
+      Common capabilities: completion, hover, definition, references,
+      diagnostics, code actions, rename, formatting.
+    example: |
+      const connection = createConnection(ProtocoLConnection);
+      const documents = new TextDocuments(TextDocument);
+      connection.onInitialize((params) => ({
+        capabilities: {
+          textDocumentSync: TextDocumentSyncKind.Incremental,
+          completionProvider: { resolveProvider: true, triggerCharacters: ["."] },
+          hoverProvider: true,
+          definitionProvider: true,
+          referencesProvider: true,
+          codeActionProvider: true
+        }
+      }));
+      documents.listen(connection);
+      connection.listen();
+
+  - id: LSP-002
+    name: Diagnostics Push
+    category: analysis
+    description: Push diagnostics (errors/warnings) to client.
+    text: |
+      Send diagnostics on document change.
+      Include severity, range, message, source.
+    example: |
+      documents.onDidChangeContent((change) => {
+        const diagnostics: Diagnostic[] = [];
+        const text = change.document.getText();
+        // Analyze text, push diagnostics
+        const match = /TODO/.exec(text);
+        if (match) {
+          diagnostics.push({
+            severity: DiagnosticSeverity.Information,
+            range: { start: { line: 0, character: match.index },
+                     end: { line: 0, character: match.index + 4 } },
+            message: "TODO found",
+            source: "my-lsp"
+          });
+        }
+        connection.sendDiagnostics({ uri: change.document.uri, diagnostics });
+      });
+
+  - id: LSP-003
+    name: Code Actions
+    category: refactoring
+    description: Quick fixes and refactoring actions.
+    text: |
+      Return CodeAction[] for given diagnostic context.
+      Types: QuickFix, Refactor, Source, Extract.
+    example: |
+      connection.onCodeAction((params) => {
+        const actions: CodeAction[] = [];
+        for (const diag of params.context.diagnostics) {
+          if (diag.code === "unused-import") {
+            actions.push({
+              title: "Remove unused import",
+              kind: CodeActionKind.QuickFix,
+              edit: { changes: { [params.textDocument.uri]: [TextEdit.del(diag.range)] } },
+              diagnostics: [diag]
+            });
+          }
+        }
+        return actions;
+      });
+
+  - id: LSP-004
+    name: Go-to-Definition
+    category: navigation
+    description: Jump to symbol definition.
+    example: |
+      connection.onDefinition((params) => {
+        const doc = documents.get(params.textDocument.uri);
+        const word = getWordAtPosition(doc, params.position);
+        const location = findDefinition(word);
+        return location ? Location.create(location.uri, location.range) : null;
+      });
+
+  - id: LSP-005
+    name: Hover Information
+    category: analysis
+    description: Show documentation on hover.
+    example: |
+      connection.onHover((params) => {
+        const doc = documents.get(params.textDocument.uri);
+        const word = getWordAtPosition(doc, params.position);
+        const info = getDocumentation(word);
+        return info ? { contents: { kind: "markdown", value: info } } : null;
+      });
+
+  - id: LSP-006
+    name: Transport Configuration
+    category: setup
+    description: |
+      LSP transport options: stdio (most common), IPC, TCP, pipe.
+    text: |
+      stdio: Default, works with all editors
+      IPC: VS Code–specific, faster
+      TCP: Remote debugging, network servers
+
+      Client launch config (VS Code):
+      "languageServer": {
+        "command": "node",
+        "args": ["./server/out/main.js", "--stdio"],
+        "transport": "stdio"
+      }
+
+  - id: LSP-007
+    name: Incremental Sync
+    category: performance
+    description: |
+      Use incremental text sync for large files.
+    text: |
+      TextDocumentSyncKind.Incremental sends only changed ranges.
+      TextDocumentSyncKind.Full sends entire document (simpler but slower).
+      Best practice: Use Incremental for production LSP servers.

package/.agent/skills/tooling/ide-extension/data/vscode-patterns.yaml

@@ -0,0 +1,172 @@
+# VS Code Extension Patterns — HSA Tier 3 Data
+# IDE Extension Development Skill
+version: "1.0.0"
+
+patterns:
+  # ==========================================================================
+  # Extension Host Architecture
+  # ==========================================================================
+  - id: VSCODE-001
+    name: Extension Activation
+    category: lifecycle
+    description: |
+      Extensions run in isolated Extension Host process.
+      Use activation events to lazy-load.
+    text: |
+      Activation Events (package.json):
+      - onLanguage:typescript — When TS file opened
+      - onCommand:ext.cmd — When command invoked
+      - workspaceContains:**/*.rs — When workspace has Rust files  
+      - onStartupFinished — After VS Code fully loaded (use sparingly)
+      - * — Always active (avoid: blocks startup)
+    example: |
+      // package.json
+      "activationEvents": ["onLanguage:python", "onCommand:ext.analyze"]
+
+      // extension.ts
+      export function activate(context: ExtensionContext) {
+        const cmd = commands.registerCommand("ext.analyze", async () => {
+          const editor = window.activeTextEditor;
+          if (!editor) return;
+          // ... analyze document
+        });
+        context.subscriptions.push(cmd);
+      }
+
+  - id: VSCODE-002
+    name: Contribution Points
+    category: api
+    description: |
+      Declarative UI contributions in package.json.
+    text: |
+      Key contribution points:
+      - commands: Register command palette entries
+      - menus: Context menus, editor title, explorer context
+      - views: Custom tree views in sidebar
+      - viewsContainers: Custom activity bar icons
+      - configuration: Settings page entries
+      - keybindings: Keyboard shortcuts
+      - languages: Language declarations
+      - grammars: TextMate grammar for syntax highlighting
+      - themes: Color themes
+      - snippets: Code snippets
+
+  - id: VSCODE-003
+    name: Webview Panel
+    category: ui
+    description: |
+      Custom HTML/CSS/JS UI in editor panels.
+    text: |
+      Best practices:
+      - Use message passing (postMessage/onDidReceiveMessage)
+      - Persist state with getState/setState
+      - Use webviewOptions.retainContextWhenHidden sparingly
+      - Apply CSP: default-src 'none'
+      - Use webview.asWebviewUri for local resources
+    example: |
+      const panel = window.createWebviewPanel(
+        "myView", "My Panel", ViewColumn.One,
+        { enableScripts: true, retainContextWhenHidden: false }
+      );
+      panel.webview.html = getHtml(panel.webview);
+      panel.webview.onDidReceiveMessage((msg) => {
+        if (msg.command === "getData") {
+          panel.webview.postMessage({ data: result });
+        }
+      });
+
+  - id: VSCODE-004
+    name: TreeView Provider
+    category: ui
+    description: |
+      Custom tree views in sidebar/explorer.
+    text: |
+      Implement TreeDataProvider<T> interface:
+      - getChildren(element?): Return child nodes
+      - getTreeItem(element): Return TreeItem with label, icon, command
+      - onDidChangeTreeData: Event to refresh tree
+    example: |
+      class MyTreeProvider implements TreeDataProvider<MyItem> {
+        private _onDidChange = new EventEmitter<MyItem | undefined>();
+        readonly onDidChangeTreeData = this._onDidChange.event;
+        
+        getChildren(el?: MyItem): MyItem[] {
+          return el ? el.children : this.rootItems;
+        }
+        getTreeItem(el: MyItem): TreeItem {
+          return { label: el.name, collapsibleState: el.children.length ? 1 : 0 };
+        }
+        refresh() { this._onDidChange.fire(undefined); }
+      }
+
+  - id: VSCODE-005
+    name: Extension Testing
+    category: testing
+    description: |
+      Test extensions in Extension Development Host.
+    text: |
+      Setup:
+      1. Use @vscode/test-electron for integration tests
+      2. Run tests in isolated VS Code instance
+      3. Use mocha as test runner
+      4. Mock vscode API for unit tests
+    example: |
+      // src/test/suite/extension.test.ts
+      suite("Extension Test Suite", () => {
+        test("Command should activate", async () => {
+          await vscode.commands.executeCommand("ext.doSomething");
+          assert.ok(true);
+        });
+      });
+
+  - id: VSCODE-006
+    name: Diagnostic Provider
+    category: api
+    description: |
+      Report errors/warnings in Problems panel.
+    text: |
+      Use DiagnosticCollection to manage diagnostics.
+      Update on document change events.
+    example: |
+      const diagnostics = languages.createDiagnosticCollection("myLinter");
+      workspace.onDidChangeTextDocument((e) => {
+        const diags: Diagnostic[] = [];
+        // analyze document, push Diagnostic objects
+        diagnostics.set(e.document.uri, diags);
+      });
+
+  - id: VSCODE-007
+    name: CompletionItem Provider
+    category: api
+    description: |
+      Provide autocomplete suggestions.
+    text: |
+      Register CompletionItemProvider with trigger characters.
+      Return CompletionItem[] with label, kind, detail, insertText.
+    example: |
+      languages.registerCompletionItemProvider("typescript", {
+        provideCompletionItems(doc, pos) {
+          const items: CompletionItem[] = [
+            { label: "myFunction", kind: CompletionItemKind.Function,
+              insertText: new SnippetString("myFunction(${1:arg})"),
+              detail: "Custom function" }
+          ];
+          return items;
+        }
+      }, ".");
+
+  - id: VSCODE-008
+    name: Publishing Extension
+    category: distribution
+    description: |
+      Package and publish to VS Code Marketplace.
+    text: |
+      Steps:
+      1. npm install -g @vscode/vsce
+      2. vsce package → creates .vsix
+      3. vsce publish → publishes to marketplace
+      Requirements:
+      - publisher in package.json
+      - Azure DevOps PAT token
+      - README.md with screenshots
+      - CHANGELOG.md

package/.agent/skills/tooling/mcp/META.yaml

@@ -0,0 +1,80 @@
+name: mcp
+version: "1.0.0"
+display: Model Context Protocol
+category: tooling
+tier: 1
+priority: 1
+
+desc: "MCP server & client development. JSON-RPC 2.0, transport (stdio/Streamable HTTP), tool/resource/prompt primitives, OAuth 2.1, and production patterns."
+
+  ### Data Files (3 domains, ~24 patterns)
+  - transport-patterns.yaml: stdio vs Streamable HTTP, config (8)
+  - tool-design.yaml: stateless tools, pagination, error handling (8)
+  - security.yaml: OAuth 2.1 flows, input validation, rate limiting (8)
+
+triggers:
+  file_patterns:
+    # Config
+    - "mcp.json"
+    - "mcp-config.json"
+    - ".mcp.json"
+    - "claude_desktop_config.json"
+    # Server structure
+    - "**/mcp-server/**"
+    - "**/mcp/**/*.ts"
+    - "**/tools/*.ts"
+    - "**/resources/*.ts"
+    - "**/prompts/*.ts"
+  keywords:
+    # Core
+    - MCP
+    - Model Context Protocol
+    - mcp server
+    - mcp client
+    - mcp tool
+    - mcp resource
+    - mcp prompt
+    # Protocol
+    - JSON-RPC
+    - JSON-RPC 2.0
+    - jsonrpc
+    # Transport
+    - stdio transport
+    - streamable http
+    - sse transport
+    # SDK
+    - "@modelcontextprotocol/sdk"
+    - "mcp sdk"
+    - "from mcp import"
+    # Primitives
+    - tool definition
+    - resource template
+    - prompt template
+    # Auth
+    - OAuth 2.1
+    - mcp auth
+
+caps:
+  - JSON-RPC 2.0 protocol (request/response/notification)
+  - Host ↔ Client ↔ Server architecture
+  - Transport: stdio (local/dev) vs Streamable HTTP (remote/prod)
+  - Tool primitives: stateless, idempotent, JSON Schema validation
+  - Resource primitives: URI templates, dynamic content
+  - Prompt primitives: reusable prompt templates
+  - OAuth 2.1 authentication (mandatory for HTTP transport)
+  - Bounded context per server (single responsibility)
+  - Pagination tokens for large result sets
+  - Error classification (recoverable vs fatal, -32xxx codes)
+  - Input validation & sanitization
+  - Containerized deployment patterns
+  - SDK patterns: TypeScript (@modelcontextprotocol/sdk), Python (mcp)
+
+related_skills:
+  - ai-agents
+  - api-protocols
+  - security
+
+hsa_adapter:
+  enabled: true
+  data_dir: "skills/tooling/mcp/data"
+  preload_data: true