By cyrock-ai
Skills for building high-quality Eclipse Store and Eclipse Serializer applications in Java — storage lifecycle, Lazy<T>, GigaMap, JCache, Spring Boot integration, schema evolution, and custom type handlers.
Guide Claude on using Eclipse Store's JCache (JSR-107) provider — standalone caches, caches backed by an `EmbeddedStorageManager`, expiry and eviction policies, entry listeners, read-through / write-through with `CacheLoader` / `CacheWriter`, properties-file configuration, and integrations with Hibernate second-level cache and Spring's cache abstraction. **Apply this skill whenever a service / repository / facade method has an expensive read** (database query, HTTP call, cross-aggregate computation), whenever a Spring `@Service` is being designed and `@Cacheable` may apply, whenever a Hibernate model is being designed and a second-level cache is on the table, or whenever a read-heavy aggregate is being reviewed for performance. The decisions taken here — *which* operation to memoize, *what* TTL, persistent vs. ephemeral entries, cache-aside vs. read-through, where the cache lives in the bean graph — ossify in the service-layer signature the moment it is committed; retrofitting them later means changing every caller. Load this skill *before* a `@Cacheable` annotation or `JCacheManagerCustomizer` bean is added. Also use this skill when the user asks to "use JCache", "JSR-107", "Hibernate second-level cache", "@Cacheable", "JCacheManagerCustomizer", "CachingProvider", "CacheConfiguration.Builder", "CacheConfiguration.load", "eclipsestore-cache.properties", "storeByValue", "ModifiedExpiryPolicy", "AccessedExpiryPolicy", "EvictionManager.Interval", "EvictionPolicy.LeastRecentlyUsed", "CacheLoader", "CacheWriter", "read-through", "write-through", "cache-aside", "JMX cache stats", or "spring.jpa.properties.hibernate.cache.eclipsestore".
Guide Claude on safe concurrent access to Eclipse Store object graphs — the "mutate + store under the same lock" rule, what is and isn't thread-safe (`EmbeddedStorageManager`, channels, `Storer`, `GigaMap`, `Lazy<T>`, JCache, `Serializer`), and which strategy to use (`XThreads.executeSynchronized`, `ReentrantReadWriteLock`, `LockedExecutor`, `LockScope`, `StripeLockedExecutor`, `StripeLockScope`, Spring `@Read` / `@Write` / `@Mutex`). **Apply this skill whenever an Eclipse Store object model, root aggregate, or service / repository / facade layer is being designed, reviewed, or extended** — not only when the user explicitly mentions "lock" or "synchronized". In Eclipse Store the application owns thread-safety because the library is not in the read/write path, so locking decisions are part of the data model and service-layer design itself: where the locks live, which methods are read vs. write, where `store()` is called, whether to use `LockScope` / `StripeLockedExecutor` / Spring `@Read`/`@Write`/`@Mutex`. If you are sketching entities, root containers, repositories, or any API that mutates persistent state, load this skill before proposing a structure. Also use this skill when the user asks to "handle concurrent access", "make this thread-safe", "synchronize storing", "lock around store()", "ConcurrentModificationException during serialize", "share a Storer across threads", "what's thread-safe in Eclipse Store", "GigaMap concurrency", "gigaMap.store vs storageManager.store", "iterators leaking read locks", "stress-test concurrent writes", or asks why a multi-threaded app is producing inconsistent state on disk.
Guide Claude on configuring an Eclipse Store embedded storage — directories, channel count, backup, deletion, housekeeping intervals/budgets, file size thresholds, read-only mode, and external configuration loading from INI/XML/YAML/JSON/HOCON. Use this skill when the user asks to "configure storage", "set the storage directory", "use INI config", "load config from XML", "change channel count", "backup directory", "deletion directory", "truncation directory", "housekeeping budget", "data file minimum size", "read-only storage", "EmbeddedStorageConfiguration", "storage-embedded- configuration", "ConfigurationLoader", "StorageChannelCountProvider", "StorageFileProvider", or needs help sizing channels/budgets or picking a config file format.
Guide Claude on writing and registering custom binary type handlers for Eclipse Store / Eclipse Serializer — `CustomBinaryHandler<T>` for current-shape types, `BinaryLegacyTypeHandler.AbstractCustom<T>` for legacy reads, the `Binary` API for reading/writing fields at byte offsets. Use this skill when the user asks to "write a custom type handler", "serialize third-party type", "control binary layout", "CustomBinaryHandler", "BinaryHandler", "registerCustomTypeHandler", "XMemory", "PersistenceStoreHandler", "PersistenceLoadHandler", or needs to serialize a class Eclipse Store does not natively support (e.g., native handles, opaque third-party objects, types with computed fields).
Guide Claude on initializing, starting, and shutting down an Eclipse Store embedded database. This skill should be used when the user asks to "start EmbeddedStorage", "initialize StorageManager", "set up Eclipse Store", "bootstrap a database", "create an Eclipse Store application", "use EmbeddedStorageFoundation", "shut down storage", "add the storage-embedded dependency", or needs help with the storage lifecycle, Maven/Gradle coordinates, the difference between `EmbeddedStorage.start()` and the Foundation builder, or running multiple databases in one JVM.
Own this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimOwn this plugin?
Verify ownership to unlock analytics, metadata editing, and a verified badge. GitHub access is read-only (username + org membership).
Sign in to claimBased on adoption, maintenance, documentation, and repository signals. Not a security audit or endorsement.
🚧 Work in Progress. This skill set is under active development. Skill content, trigger surfaces, file layout, and per-target output formats may change without notice. Pin to a specific commit if you depend on a stable shape, and expect breaking changes between versions until a 1.0 release.
Opinionated, topic-focused skills for building applications with Eclipse Store and Eclipse Serializer, designed to be consumed by multiple AI coding agents.
The skills/ tree is the source of truth — plain, prescriptive Markdown with
per-topic references. From it we emit native formats for Claude Code, Cursor,
Windsurf, GitHub Copilot, Continue, Aider, and Cline so each tool loads the
same patterns instead of guessing from stale web content.
When you ask any of these tools to bootstrap a database, store a graph, add a
Lazy<T>, build a GigaMap query, wire storage into Spring Boot, or evolve a
schema, the matching skill/rule activates and drives the answer.
| Agent | Format | Install |
|---|---|---|
| Claude Code | native plugin (.claude-plugin/ + skills/) | /plugin marketplace — see below |
| Cursor | .cursor/rules/*.mdc (Agent Requested) | node tools/port-skills.mjs --target cursor |
| Windsurf | .windsurf/rules/*.md (trigger: model_decision) | --target windsurf |
| GitHub Copilot | .github/copilot-instructions.md | --target copilot |
| Continue | .continue/rules/*.md | --target continue |
| Aider | CONVENTIONS.md | --target aider |
| Cline | .clinerules/*.md | --target cline |
Cursor, Windsurf, Continue, and Cline preserve the lazy-loading pattern by
emitting reference docs alongside each rule. Copilot and Aider inline only the
SKILL.md bodies to stay within each tool's instruction budget.
See tools/README.md for per-target output layouts,
options, and how to drop the generated files into a consuming project.
From a Claude Code session:
/plugin marketplace add cyrock-ai/eclipse-store-skills
/plugin install eclipse-store-claude@eclipse-store-claude
/reload-plugins
After reload, /plugin should show eclipse-store-claude with all skills listed under
eclipse-store-claude:<skill-name>.
# One target
node tools/port-skills.mjs --target cursor
# Every target (emits under dist/<target>/)
node tools/port-skills.mjs --target all
# Custom output location — drop directly into a consuming project
node tools/port-skills.mjs --target cursor --out /path/to/my-project
No npm install step — the generator is zero-dependency Node.js ESM.
| Skill | Covers |
|---|---|
getting-started | EmbeddedStorage.start, EmbeddedStorageFoundation, lifecycle, shutdown |
root-and-object-graph | default root, custom root, storeRoot, graph design |
storing-data | store(), storeAll(), lazy vs eager storing, BatchStorer, the "store the parent" rule |
lazy-loading | Lazy<T>, Reference<T>, deferred subgraph loading |
concurrency-and-locking | thread safety, mutate + store() under same lock, LockedExecutor / LockScope / striped, Spring @Read/@Write/@Mutex, GigaMap concurrency |
configuration | programmatic / INI / XML config, channel count, backup directory, Dev / Test / Staging / Prod best practices |
housekeeping-and-deletion | GC, file compaction, cache eviction, deletes via ref removal |
legacy-type-mapping | schema evolution — renamed / removed / retyped fields and classes |
custom-type-handlers | CustomBinaryHandler, registering handlers on the foundation |
serializer-standalone | using Eclipse Serializer without storage (RPC, exports, REST) |
storage-targets-afs | AFS backends — NIO, S3, Azure Blob, Redis, Kafka, etc. |
gigamap | GigaMap, indices, GigaQuery, bitmap/Lucene/jvector |
cache-jcache | JSR-107 cache over Eclipse Store, Hibernate L2 |
spring-boot | Spring Boot 3 starter, properties, @Autowired, @Read/@Write/@Mutex |
In Claude Code these appear as eclipse-store-claude:<skill-name>. Other
agents expose them under their own naming (e.g. Cursor rule filename,
Continue rule filename).
eclipse-store-skills/
├── .claude-plugin/ # Claude Code plugin descriptor
│ ├── plugin.json
│ └── marketplace.json
├── skills/ # source of truth
│ └── <skill-name>/
│ ├── SKILL.md
│ └── references/
│ ├── api-catalogue.md
│ ├── examples-expanded.md
│ └── pitfalls-deep-dive.md
├── tools/
│ ├── port-skills.mjs # emits rule files for non-Claude agents
│ └── README.md
└── README.md
npx claudepluginhub cyrock-ai/eclipse-store-skills --plugin eclipse-store-claudeComprehensive skill pack with 66 specialized skills for full-stack developers: 12 language experts (Python, TypeScript, Go, Rust, C++, Swift, Kotlin, C#, PHP, Java, SQL, JavaScript), 10 backend frameworks, 6 frontend/mobile, plus infrastructure, DevOps, security, and testing. Features progressive disclosure architecture for 50% faster loading.
Tools to maintain and improve CLAUDE.md files - audit quality, capture session learnings, and keep project memory current.
Develop, test, build, and deploy Godot 4.x games with Claude Code. Includes GdUnit4 testing, web/desktop exports, CI/CD pipelines, and deployment to Vercel/GitHub Pages/itch.io.
A growing collection of Claude-compatible academic workflow bundles. Covers scientific figures, manuscript writing and polishing, reviewer assessment, citation retrieval, data availability, paper reading, literature search, response letters, paper-to-PPTX conversion, and evidence-grounded Chinese invention patent drafting. Rules are organized as reusable skill folders with explicit workflows and quality checks.
Create new skills, improve existing skills, and measure skill performance. Use when users want to create a skill from scratch, update or optimize an existing skill, run evals to test a skill, or benchmark skill performance with variance analysis.
Unity Development Toolkit - Expert agents for scripting/refactoring/optimization, script templates, and Agent Skills for Unity C# development