@nockdev/awf 6.2.0 → 6.2.2

package/.agent/skills/tooling/cli-dev/data/frameworks.yaml

@@ -0,0 +1,128 @@
+# CLI Frameworks Comparison — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: CLI-FW-001
+    name: commander.js
+    category: node
+    description: Node.js/TypeScript CLI framework.
+    text: |
+      Strengths: Widely used, mature, npm ecosystem
+      Weaknesses: Manual type inference
+    example: |
+      import { Command } from "commander";
+
+      const program = new Command()
+        .name("mycli")
+        .version("1.0.0")
+        .description("My CLI tool");
+
+      program.command("init <name>")
+        .description("Initialize project")
+        .option("-t, --template <template>", "Template", "default")
+        .option("--no-git", "Skip git init")
+        .action((name, options) => {
+          console.log(`Creating ${name} with template ${options.template}`);
+        });
+
+      program.parse();
+
+  - id: CLI-FW-002
+    name: clap (Rust)
+    category: rust
+    description: Rust CLI framework with derive macros.
+    text: |
+      Strengths: Type-safe, derive macros, fast compile-time validation
+      Weaknesses: Rust-only
+    example: |
+      use clap::{Parser, Subcommand};
+
+      #[derive(Parser)]
+      #[command(name = "mycli", version, about)]
+      struct Cli {
+        #[command(subcommand)]
+        command: Commands,
+        #[arg(short, long)]
+        verbose: bool,
+      }
+
+      #[derive(Subcommand)]
+      enum Commands {
+        Init { name: String, #[arg(short, long, default_value = "default")] template: String },
+        Build { #[arg(long)] release: bool },
+      }
+
+      fn main() {
+        let cli = Cli::parse();
+        match cli.command {
+          Commands::Init { name, template } => println!("Init {name} with {template}"),
+          Commands::Build { release } => println!("Building (release: {release})"),
+        }
+      }
+
+  - id: CLI-FW-003
+    name: cobra (Go)
+    category: go
+    description: Go CLI framework with auto-generated docs.
+    text: |
+      Strengths: Subcommands, auto shell completion, auto docs
+      Weaknesses: Verbose setup
+    example: |
+      var rootCmd = &cobra.Command{
+        Use:   "mycli",
+        Short: "My CLI tool",
+      }
+
+      var initCmd = &cobra.Command{
+        Use:   "init [name]",
+        Short: "Initialize project",
+        Args:  cobra.ExactArgs(1),
+        Run: func(cmd *cobra.Command, args []string) {
+          template, _ := cmd.Flags().GetString("template")
+          fmt.Printf("Creating %s with %s\n", args[0], template)
+        },
+      }
+
+      func init() {
+        initCmd.Flags().StringP("template", "t", "default", "Template to use")
+        rootCmd.AddCommand(initCmd)
+      }
+
+  - id: CLI-FW-004
+    name: Click (Python)
+    category: python
+    description: Python CLI with decorator-based API.
+    example: |
+      import click
+
+      @click.group()
+      @click.version_option("1.0.0")
+      def cli():
+          """My CLI tool"""
+          pass
+
+      @cli.command()
+      @click.argument("name")
+      @click.option("--template", "-t", default="default", help="Template")
+      def init(name, template):
+          """Initialize project"""
+          click.echo(f"Creating {name} with {template}")
+
+      if __name__ == "__main__":
+          cli()
+
+  - id: CLI-FW-005
+    name: Framework Comparison
+    category: comparison
+    description: |
+      Side-by-side framework comparison.
+    text: |
+      | Feature | commander.js | clap | cobra | Click |
+      |---------|-------------|------|-------|-------|
+      | Language | Node.js/TS | Rust | Go | Python |
+      | Type safety | Manual | Compile-time | Runtime | Runtime |
+      | Subcommands | ✅ | ✅ | ✅ | ✅ |
+      | Auto-complete | Plugin | Built-in | Built-in | Plugin |
+      | Auto docs | ❌ | ✅ | ✅ Man pages | ❌ |
+      | Testing | Unit tests | Integration | Test helpers | CliRunner |
+      | Ecosystem | npm | crates.io | Go modules | PyPI |

package/.agent/skills/tooling/cli-dev/data/output-formats.yaml

@@ -0,0 +1,58 @@
+# CLI Output Formats — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: CLI-OUT-001
+    name: Structured Output
+    category: output
+    description: |
+      Support multiple output formats.
+    example: |
+      function output(data: unknown, format: string) {
+        switch (format) {
+          case "json": console.log(JSON.stringify(data, null, 2)); break;
+          case "yaml": console.log(yaml.stringify(data)); break;
+          case "csv": console.log(toCSV(data)); break;
+          case "table": default: console.log(renderTable(data)); break;
+        }
+      }
+
+      program.option("--format <format>", "Output format", "table");
+
+  - id: CLI-OUT-002
+    name: Exit Codes
+    category: output
+    description: |
+      Standard exit codes for CLI tools.
+    text: |
+      | Code | Meaning | When |
+      |------|---------|------|
+      | 0 | Success | Normal completion |
+      | 1 | General error | Runtime errors |
+      | 2 | Usage error | Invalid args/options |
+      | 126 | Not executable | Permission denied |
+      | 127 | Not found | Command not found |
+      | 130 | Interrupted | Ctrl+C (SIGINT) |
+
+  - id: CLI-OUT-003
+    name: Progress Indicators
+    category: output
+    description: |
+      Show progress for long-running operations.
+    example: |
+      import ora from "ora";
+      import cliProgress from "cli-progress";
+
+      // Spinner
+      const spinner = ora("Processing...").start();
+      await doWork();
+      spinner.succeed("Done!");
+
+      // Progress bar
+      const bar = new cliProgress.SingleBar();
+      bar.start(100, 0);
+      for (let i = 0; i <= 100; i++) {
+        bar.update(i);
+        await sleep(50);
+      }
+      bar.stop();

package/.agent/skills/tooling/cli-dev/data/ux-patterns.yaml

@@ -0,0 +1,97 @@
+# CLI UX Patterns — HSA Tier 3 Data
+version: "1.0.0"
+
+patterns:
+  - id: CLI-UX-001
+    name: Progressive Discovery
+    category: ux
+    description: |
+      Guide users from beginner to expert progressively.
+    text: |
+      Level 1: mycli → Show help + suggest commands
+      Level 2: mycli --help → Detailed help with examples
+      Level 3: mycli <cmd> --help → Command-specific help
+      Level 4: mycli suggest → AI-powered context suggestions
+      Level 5: mycli --verbose → Expert debug output
+
+  - id: CLI-UX-002
+    name: Color and Formatting
+    category: ux
+    description: |
+      Use colors, icons, and formatting for readability.
+    text: |
+      Libraries:
+      - chalk (Node.js): Color output
+      - ora (Node.js): Spinners
+      - cli-table3: Tables
+      - boxen: Boxed messages
+      Rules:
+      - Detect NO_COLOR env and CI environments
+      - Use stderr for progress, stdout for data
+      - Use emoji/icons sparingly (✓ ✗ ⚠ ℹ)
+
+  - id: CLI-UX-003
+    name: Interactive Prompts
+    category: ux
+    description: |
+      Interactive input with validation.
+    text: |
+      Libraries:
+      - @clack/prompts: Beautiful, modern prompts
+      - Inquirer.js: Feature-rich
+      - prompts: Lightweight
+    example: |
+      import { intro, select, text, confirm, outro } from "@clack/prompts";
+
+      intro("Welcome to MyTool");
+      const name = await text({ message: "Project name?", validate: (v) => v.length < 1 ? "Required" : undefined });
+      const framework = await select({ message: "Framework?", options: [
+        { value: "react", label: "React" },
+        { value: "vue", label: "Vue" },
+      ]});
+      const proceed = await confirm({ message: "Create project?" });
+      outro("Done!");
+
+  - id: CLI-UX-004
+    name: Help Formatting
+    category: ux
+    description: |
+      Well-formatted help output.
+    text: |
+      Structure:
+      USAGE: mycli <command> [options]
+
+      COMMANDS:
+        init      Initialize project
+        build     Build project
+        deploy    Deploy to production
+
+      OPTIONS:
+        -v, --verbose    Verbose output
+        -h, --help       Show help
+        --no-color       Disable colors
+
+      EXAMPLES:
+        $ mycli init my-project --template react
+        $ mycli deploy --env production
+
+  - id: CLI-UX-005
+    name: Error Display
+    category: ux
+    description: |
+      User-friendly error messages.
+    example: |
+      import chalk from "chalk";
+
+      function displayError(err: CLIError) {
+        console.error();
+        console.error(chalk.red.bold("Error:"), err.message);
+        if (err.suggestion) {
+          console.error(chalk.dim("Suggestion:"), err.suggestion);
+        }
+        if (err.docs) {
+          console.error(chalk.dim("Docs:"), chalk.underline(err.docs));
+        }
+        console.error();
+        process.exit(err.code || 1);
+      }

package/.agent/skills/tooling/ide-extension/META.yaml

@@ -0,0 +1,72 @@
+name: ide-extension
+version: "1.0.0"
+display: IDE Extension Development
+category: tooling
+tier: 1
+priority: 2
+
+desc: "Multi-IDE extension development. VS Code (Extension Host, Contribution Points, LSP, DAP), JetBrains (IntelliJ Plugin SDK, PSI), Neovim (Lua API, lazy.nvim). Cross-platform patterns."
+
+  ### Data Files (3 domains, ~21 patterns)
+  - vscode-patterns.yaml: Extension Host, contribution points, webview (8)
+  - lsp-patterns.yaml: Language Server Protocol, diagnostics, code actions (7)
+  - jetbrains-patterns.yaml: Plugin SDK, PSI, remote dev (6)
+
+triggers:
+  file_patterns:
+    # VS Code
+    - "extension.ts"
+    - "extension.js"
+    - "*.vsix"
+    - ".vscode/launch.json"
+    - "**/contributes/**"
+    # JetBrains
+    - "plugin.xml"
+    - "build.gradle.kts:intellij"
+    # Neovim
+    - "lua/*/init.lua"
+    - "plugin/**/*.vim"
+  keywords:
+    - vscode extension
+    - vs code extension
+    - jetbrains plugin
+    - intellij plugin
+    - neovim plugin
+    - neovim lua
+    - language server
+    - LSP
+    - language server protocol
+    - DAP
+    - debug adapter
+    - activation events
+    - contribution points
+    - webview
+    - Extension Host
+    - extension development host
+    - vscode api
+    - TextDocument
+    - CompletionProvider
+    - DiagnosticCollection
+
+caps:
+  - VS Code Extension Host architecture (isolated process)
+  - package.json contribution points (commands, views, keybindings)
+  - Activation events (onLanguage, onCommand, workspaceContains)
+  - Language Server Protocol (LSP) implementation
+  - Debug Adapter Protocol (DAP) implementation
+  - Webview panels (React/Vue in VS Code sidebar/editor)
+  - JetBrains IntelliJ Plugin SDK 2.x
+  - PSI (Program Structure Interface) tree traversal
+  - Neovim Lua 5.1 plugin architecture
+  - lazy.nvim plugin management
+  - Extension testing (Extension Development Host)
+  - Publishing (VSIX, JetBrains Marketplace, Neovim package managers)
+
+related_skills:
+  - typescript
+  - mcp
+
+hsa_adapter:
+  enabled: true
+  data_dir: "skills/tooling/ide-extension/data"
+  preload_data: true

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)