chore: fix after nx v21 update

Author: tinesoft

.devcontainer/postCreateCommand.sh

@@ -11,4 +11,9 @@ export PATH="$BUN_INSTALL/bin:$PATH"
 
 # Install NPM dependencies
 echo "⚙️ Installing NPM dependencies..."
-bun install --frozen-lockfile
+bun install --frozen-lockfile
+
+# Clean system cache
+echo "🧹 Cleaning cache..."
+sudo apt-get autoclean
+sudo apt-get clean

.github/copilot-instructions.md

@@ -0,0 +1,76 @@
+# Copilot Instructions for nxrocks
+
+## Big Picture
+
+- **Monorepo managed by Nx (v21+) and Bun.**  
+  Nx plugins extend support for JVM (Spring Boot, Quarkus, Micronaut, Ktor), Flutter/Dart (Flutter, Melos), and cross-language monorepos.
+- **Plugin Architecture:**  
+  Each plugin (`packages/nx-*`) has its own generators, executors, and utilities. Shared code lives in `packages/common` and `packages/common-jvm`.
+- **E2E Testing:**  
+  Each plugin has a matching e2e project in `e2e/`. Smoke tests (`e2e/smoke`) validate workspace creation and plugin compatibility with new Nx versions.
+- **Custom CLIs:**  
+  `create-nx-*` CLIs (see `packages/create-nx-*`) bootstrap Nx workspaces with pre-installed plugins and required runtime dependencies.
+
+## Developer Workflows
+
+- **Build:**  
+  `bun nx build <project>` or `nx build <project>`
+- **Test:**  
+  `bun nx test <project>` or `nx test <project>`
+- **Lint:**  
+  `bun nx lint <project>`
+- **Format:**  
+  Use `nx run <project>:format` or `nx apply-format <project>` (not `nx format <project>`, which is reserved by Nx CLI)
+- **Generate:**  
+  `nx generate @nxrocks/<plugin>:new ...` for new projects
+- **Dependency Graph:**  
+  `nx graph` or `nx dep-graph` visualizes cross-language dependencies
+- **CI:**  
+  Nx Cloud is used for distributed caching and CI. Wrapper scripts for Maven/Gradle/Flutter are preferred.
+
+## Project-Specific Conventions
+
+- **Executors:**  
+  Plugins map Nx targets to native build tools (e.g., `build` → `mvnw package` or `gradlew build`).  
+  Always use project-local wrappers (`./mvnw`, `./gradlew`) unless `--ignoreWrapper` is specified.
+- **Task Dependencies:**  
+  Build/test tasks auto-install dependent libraries via the `install` target.
+- **Formatting:**  
+  JVM projects use [Spotless](https://github.com/diffplug/spotless).
+- **Multi-module Support:**  
+  Plugins support multi-module projects for Maven/Gradle.
+- **Proxy Support:**  
+  Plugins respect `http_proxy`/`https_proxy` environment variables for API calls to project generators.
+- **Melos Integration:**  
+  For Dart/Flutter monorepos, root-level NPM scripts (e.g., `melos-bootstrap`, `melos-clean`) run Melos commands via Nx.
+
+## Integration Points
+
+- **Spring Initializr, Quarkus, Micronaut, Ktor:**  
+  Generators fetch starter projects from official APIs.
+- **Flutter, Melos:**  
+  See `nx-flutter`, `nx-melos` and root `package.json` scripts for Dart/Flutter workflows.
+- **Nx Cloud:**  
+  Used for caching and CI. See `nx.json` for configuration.
+
+## Examples
+
+- Generate a Spring Boot app:  
+  `nx generate @nxrocks/nx-spring-boot:new my-app --projectType application`
+- Build a Quarkus app:  
+  `nx build my-quarkus-app`
+- Format a Micronaut app:  
+  `nx run my-micronaut-app:format`
+- Run Melos bootstrap:  
+  `npx nx melos-bootstrap --since=main`
+
+## References
+
+- See each plugin's `README.md` for detailed options and usage.
+- E2E test specs in `e2e/<plugin>-e2e/tests/` show real workflows and edge cases.
+- For advanced Nx usage, see `nx.json`, `project.json`, and `tools/`.
+
+---
+
+**Feedback requested:**  
+Are any sections unclear, missing, or too generic? Let me know what needs refinement or if you want deeper coverage of any workflow, plugin, or integration.

.github/workflows/ci.yml

@@ -3,49 +3,37 @@ name: CI
 on:
   push:
     branches:
-      - develop
+      - main
   pull_request:
 
-# Needed for nx-set-shas when run on the main branch
 permissions:
   actions: read
   contents: read
 
 jobs:
-  ci:
+  main:
     runs-on: ubuntu-latest
-    env:
-      NX_CLOUD_ACCESS_TOKEN: ${{ secrets.NX_CLOUD_ACCESS_TOKEN }}
-      ANDROID_SDK_VERSION: 34
-      FLUTTER_VERSION: 3.19.3
-      JDK_VERSION: 17.0.11
-      JDK_DISTRO: ms
-      JAVA_OPTIONS: '-Xmx3g'
-    timeout-minutes: 120
     steps:
-      - name: Checkout Repo
-        uses: actions/checkout@v4
+      - uses: actions/checkout@v4
         with:
-          # We need to fetch all branches and commits so that Nx affected has a base to compare against.
+          filter: tree:0
           fetch-depth: 0
 
-      - name: Install node, bun, and dependencies
-        uses: ./.github/actions/install-dependencies
-
-      # Validating Launch Templates
-      - run: bunx nx-cloud validate --workflow-file="./.nx/workflows/agents.yaml"
-
-      # Connect your workspace on nx.app and uncomment this to enable task distribution.
-      # The "--stop-agents-after" is optional, but allows idle agents to shut down once the "e2e" targets have been requested
-      - run: bunx nx-cloud start-ci-run --distribute-on=".nx/workflows/distribution-config.yaml" --stop-agents-after="e2e-ci" --with-env-vars="ANDROID_SDK_VERSION,FLUTTER_VERSION,JDK_VERSION,JDK_DISTRO,JAVA_OPTIONS"
-
-      # This line is needed for nx affected to work when CI is running on a PR
-      - run: git branch --track develop origin/develop || exit 0
-
-      - name: Derive appropriate SHAs for base and head for `nx affected` commands
-        uses: nrwl/nx-set-shas@v4
+      - uses: oven-sh/setup-bun@v1
         with:
-          main-branch-name: 'develop'
-
-      - run: bunx nx-cloud record -- nx format:check
-      - run: bunx nx affected -t lint test-ci build e2e-ci --parallel=5 --exclude=smoke
+          bun-version: latest
+
+      # This enables task distribution via Nx Cloud
+      # Run this command as early as possible, before dependencies are installed
+      # Learn more at https://nx.dev/ci/reference/nx-cloud-cli#npx-nxcloud-startcirun
+      # Uncomment this line to enable task distribution
+      # - run: bunx nx start-ci-run --distribute-on="3 linux-medium-js" --stop-agents-after="build"
+
+      - run: bun install --no-cache
+
+      # Prepend any command with "nx-cloud record --" to record its logs to Nx Cloud
+      # - run: bun nx-cloud record -- echo Hello World
+      - run: bun nx run-many -t lint test build
+      # Nx Cloud recommends fixes for failures to help you get CI green faster. Learn more: https://nx.dev/ci/features/self-healing-ci
+      - run: bun nx fix-ci
+        if: always()

.gitignore

@@ -40,7 +40,6 @@ v8-compile-cache-0
 Thumbs.db
 
 # Nx files
-/migrations.json
 .nx/cache
 .nx/workspace-data
 .cursor/rules/nx-rules.mdc

.kiro/settings/mcp.json

@@ -0,0 +1,3 @@
+{
+  "mcpServers": {}
+}

.kiro/steering/product.md

@@ -0,0 +1,20 @@
+# NxRocks Product Overview
+
+NxRocks is a collection of Nx plugins that enhance Nx workspaces with support for various frameworks and technologies beyond the typical JavaScript/TypeScript ecosystem.
+
+## Core Plugins
+
+- **nx-spring-boot**: Spring Boot project support with generators and executors
+- **nx-flutter**: Flutter development with first-class Nx integration
+- **nx-quarkus**: Quarkus framework support for Java microservices
+- **nx-micronaut**: Micronaut framework integration
+- **nx-melos**: Melos support for Flutter monorepos
+- **nx-ktor**: Ktor framework support for Kotlin server development
+
+## Custom CLIs
+
+Each plugin has a corresponding `create-nx-*` CLI tool for bootstrapping new workspaces with the respective technology pre-configured.
+
+## Target Audience
+
+Developers who want to use Nx's powerful monorepo capabilities with JVM-based frameworks (Spring Boot, Quarkus, Micronaut, Ktor) and Flutter applications.

.kiro/steering/structure.md

@@ -0,0 +1,86 @@
+# Project Structure & Organization
+
+## Monorepo Layout
+
+```
+nxrocks/
+├── packages/           # Library packages (libsDir)
+├── e2e/               # E2E test applications (appsDir)
+├── tools/             # Build and development scripts
+└── images/            # Documentation assets
+```
+
+## Package Categories
+
+### Core Libraries
+
+- **common**: Shared utilities across all plugins
+- **common-cli**: CLI-specific shared functionality
+- **common-jvm**: JVM-specific shared utilities
+
+### Nx Plugins
+
+- **nx-spring-boot**: Spring Boot integration
+- **nx-flutter**: Flutter development support
+- **nx-quarkus**: Quarkus framework support
+- **nx-micronaut**: Micronaut framework support
+- **nx-melos**: Melos monorepo tool integration
+- **nx-ktor**: Ktor framework support
+
+### CLI Tools
+
+- **create-nx-spring-boot**: Bootstrap Spring Boot workspaces
+- **create-nx-flutter**: Bootstrap Flutter workspaces
+- **create-nx-quarkus**: Bootstrap Quarkus workspaces
+- **create-nx-micronaut**: Bootstrap Micronaut workspaces
+- **create-nx-ktor**: Bootstrap Ktor workspaces
+
+## Standard Package Structure
+
+```
+packages/[package-name]/
+├── src/
+│   ├── executors/         # Nx executors (build, test, run, etc.)
+│   ├── generators/        # Code generators and schematics
+│   ├── migrations/        # Migration scripts
+│   ├── utils/            # Package-specific utilities
+│   ├── core/             # Core functionality
+│   ├── graph/            # Dependency graph plugins
+│   └── index.ts          # Main export
+├── testing/              # Test utilities (if applicable)
+├── recipes/              # Recipe configurations (JVM plugins)
+├── generators.json       # Generator definitions
+├── executors.json        # Executor definitions
+├── migrations.json       # Migration definitions
+├── package.json
+├── project.json          # Nx project configuration
+├── tsconfig.lib.json     # TypeScript config for library
+├── tsconfig.spec.json    # TypeScript config for tests
+└── jest.config.ts        # Jest configuration
+```
+
+## E2E Test Structure
+
+```
+e2e/[plugin-name]-e2e/
+├── tests/                # Test specifications
+├── jest.config.ts        # Jest configuration
+├── project.json          # Nx project configuration
+└── tsconfig.spec.json    # TypeScript config
+```
+
+## Naming Conventions
+
+- **Packages**: `@nxrocks/[name]` (scoped)
+- **Executors**: Kebab-case (e.g., `build-image`, `check-format`)
+- **Generators**: Kebab-case (e.g., `project`, `link`)
+- **Files**: Kebab-case for configs, camelCase for TypeScript
+- **Directories**: Kebab-case
+
+## Configuration Files
+
+- **generators.json**: Defines available generators with schemas
+- **executors.json**: Defines available executors with implementations
+- **migrations.json**: Defines migration scripts for version updates
+- **project.json**: Nx-specific project configuration
+- **package.json**: Standard npm package configuration with workspace dependencies

.kiro/steering/tech.md

@@ -0,0 +1,77 @@
+# Technology Stack & Build System
+
+## Build System
+
+- **Primary**: Nx monorepo with Bun as package manager
+- **TypeScript**: ES2022 target with Node.js Next module resolution
+- **Bundler**: SWC for fast TypeScript compilation
+- **Testing**: Jest with parallel execution
+- **Linting**: ESLint with Nx flat config
+- **Formatting**: Prettier
+- **CI/CD**: Semantic release with independent package versioning
+
+## Key Dependencies
+
+- **@nx/devkit**: Core Nx development toolkit
+- **@swc/core**: Fast TypeScript/JavaScript compiler
+- **enquirer**: Interactive CLI prompts
+- **node-fetch**: HTTP client for API calls
+- **js-yaml**: YAML parsing for configuration
+- **xmlbuilder2**: XML generation for build files
+
+## Common Commands
+
+### Development
+
+```bash
+# Build all packages
+bun build
+
+# Run tests
+bun test
+
+# Run linting
+bun lint
+
+# Run e2e tests
+bun e2e
+
+# Format code
+bun format
+```
+
+### Nx-specific
+
+```bash
+# Build affected packages
+bun affected:build
+
+# Test affected packages
+bun affected:test
+
+# View dependency graph
+bun graph
+
+# Run specific target for all packages
+bunx nx run-many --target build --parallel 4
+```
+
+### Local Development
+
+```bash
+# Start local registry for testing
+bun start-local-registry
+
+# Populate local registry with built packages
+bunx nx populate-local-registry
+
+# Run smoke tests
+bun smoke
+```
+
+## Package Structure
+
+- All packages follow `@nxrocks/*` scoping
+- Independent versioning with semantic-release
+- Workspace protocol for internal dependencies (`workspace:*`)
+- ESM modules with TypeScript declaration maps

.vscode/settings.json

@@ -1,4 +1,15 @@
 {
   "eslint.validate": ["json"],
-  "nxConsole.generateAiAgentRules": true
+  "nxConsole.generateAiAgentRules": true,
+  "nxConsole.nxWorkspacePath": "",
+  "github.copilot.chat.agent.terminal.allowList": {
+    "ls": true,
+    "cd": true,
+    "chmod": true,
+    "echo": true,
+    "npx": true,
+    "bunx": true,
+    "bun": true,
+    "git": true
+  }
 }

.vscode/tasks.json

@@ -0,0 +1,11 @@
+{
+  "version": "2.0.0",
+  "tasks": [
+    {
+      "type": "shell",
+      "label": "Run Jest test for executor.spec.ts with debug logs",
+      "command": "bun nx test nx-spring-boot --testFile=src/executors/test/executor.spec.ts",
+      "group": "test"
+    }
+  ]
+}