scalardb

Plugin scalardb from marketplace nexus-architect in wfukatsu/nexus-architect. Commands read from the repo's manifest — 2 days ago.

Skills (118)

• analyze-data-model

  Analyze an existing data layer: entities and relationships, database design quality and the current ER diagram. Runs after analyze.

• analyze-ui

  Inventory an existing UI: screens with their inputs, actions and access, components, user tasks, business logic in the view layer, and design tokens. Runs after investigate when there is a UI.

• analyze

  Extract the ubiquitous language, the actor-role-permission matrix and the domain-to-code mapping from an investigated codebase. Runs after investigate.

• build-app

  Build a complete ScalarDB application from a domain description: schema, configuration, Java service code and a runnable scaffold.

• capture-followup

  Queue follow-up work found during delivery (deferred tasks, out-of-scope findings, doc drift), then register approved entries as Issues under the Epic.

• config

  Generate ScalarDB configuration (database.properties, Gradle dependencies) for a backend, edition and interface; also for debugging connection or configuration errors.

• create-domain-story

  Write domain stories (Domain Storytelling) per domain, showing business processes as actors, work objects and activities; facilitated or generated. Runs after redesign.

• crud-ops

  ScalarDB CRUD API patterns (Get, Scan, Insert, Upsert, Update, Delete) with examples, for writing or reviewing transactional code without SQL.

• define-requirements

  Define requirements from documents and an interview: FR/NFR, data and transaction needs, an example map per requirement, ScalarDB / Saga applicability. Greenfield entry point; also takes over product pipeline output.

• deliver-backlog

  Drive each Issue of an Epic through implement, review, human approval and merge, resuming where it stopped and pausing at every human gate.

• design-aggregate

  Design each bounded context's tactical model with the user: aggregates, entities, value objects, invariants with examples, commands and events, plus the Domain Event Catalog. Runs after redesign.

• design-api

  Write the API contract (REST, GraphQL, gRPC or AsyncAPI): named schemas, every status code, RFC 9457 errors, and per-operation authorization, idempotency and timeouts. Runs after design-microservices.

• design-data-layer

  Design the database layer of a project that does not use ScalarDB: schema, keys, transactions and read models. For ScalarDB projects, use design-scalardb.

• design-disaster-recovery

  Set RTO and RPO, and design backups, failover and recovery procedures.

• design-graphql

  Design a schema-first Spring for GraphQL API once design-api chose GraphQL or a hybrid: SDL, resolver contracts, authorization, batching, query limits and transport.

• design-implementation

  Write coding-ready specs: the API layer (controllers, DTOs, validation), domain services, repository ports and their Fakes, value objects and exception mapping. Runs after the design phase.

• design-infrastructure

  Design the logical infrastructure: Kubernetes, Terraform, networking and per-environment configuration. For a concrete multi-cloud setup, infra:design follows.

• design-microservices

  Design the target microservice architecture and the step-by-step transformation plan from the current system. Runs after redesign.

• design-observability

  Design SLIs and SLOs, monitoring, alerting, distributed tracing and log aggregation.

• design-scalardb-analytics

  Design an HTAP analytics platform on ScalarDB Analytics with Apache Spark, a separately contracted Enterprise Option that Premium does not include.

• design-scalardb

  Design the ScalarDB schema, transaction boundaries and storage backend. ScalarDB projects only; without ScalarDB, use design-data-layer.

• design-security

  Design authentication, authorization, secrets, network security and tenant isolation, mapped to the OWASP API Security Top 10.

• design-sql-migration

  Plan moving an application's SQL to ScalarDB statement by statement: inventory, convert, and decide one route per statement in a validated manifest. Runs after the database investigation and design-scalardb.

• design-state-machine

  Model the lifecycle of aggregates with the user: states, events, guarded transitions, the state x event matrix and each transition's consistency class. Runs after redesign.

• docs

  Answer ScalarDB / ScalarDL questions that need an authoritative or version-specific source, from the version-pinned knowledge bundle first, then the official docs.

• error-handler

  Write or review ScalarDB exception handling with correct retry logic.

• estimate-cost

  Estimate cloud infrastructure, ScalarDB licensing and operating costs, with sizing.

• estimate-token-cost

  Estimate the tokens and USD cost of running the architect pipeline on a codebase, from its size and any recorded actuals.

• evaluate-ddd

  Score how closely an existing system follows DDD, on 12 criteria in 3 layers. Runs after analyze, alongside evaluate-mmi.

• evaluate-mmi

  Score modularity per module with the Modularity Maturity Index: cohesion, coupling, independence, reusability. Runs after analyze, alongside evaluate-ddd.

• evaluate-ux

  Evaluate an existing UI's UX from its inventory: Nielsen heuristics, WCAG 2.2, task efficiency, consistency and navigation, scored with source-cited findings. Runs after analyze-ui.

• explain

  Explain a generated design or code (reports, generated code, UI mocks) from its files, and on request teach the terms, functions and patterns it uses.

• export-backlog

  Turn the reports into Epics, Sub-Epics and Issues on GitLab or GitHub, after a plan the user approves.

• generate-acceptance-tests

  Make the Gherkin scenarios an executable Cucumber-JVM acceptance suite, the outer loop of TDD. Runs after generate-test-specs.

• generate-api-code

  Generate the REST API layer from the OpenAPI contract, bound one to one to operationIds: controllers, DTOs, validation, mappers and the RFC 9457 error handler.

• generate-characterization-tests

  Pin a legacy system's current behaviour in golden-master tests before a transformation step refactors or strangles it.

• generate-contract-tests

  Turn the API contract into executable tests: schema validation, Problem Details, authorization, idempotency and ArchUnit layering rules.

• generate-docs

  Write and update READMEs and docs/ pages for generated or implemented code, regenerating only its own marked sections.

• generate-graphql-code

  Generate a Spring for GraphQL API layer from the approved SDL and resolver contracts, with authorization, batch loading, query limits and a contract map.

• generate-infra-code

  Generate Kubernetes manifests, Terraform, Helm charts and the quality-gate CI workflow as a scaffold under generated/. For merge-bound infrastructure code, use infra:implement.

• generate-scalardb-code

  Generate a Spring Boot service on ScalarDB from the design: domain layer, repositories, Fakes, and unit, property and transaction integration tests. ScalarDB projects only.

• generate-test-specs

  Specify the tests before the code: Gherkin scenarios from the example maps, and contract, unit, property-per-invariant, integration and performance tests. Runs after design-implementation.

• implement-backlog

  Implement a backlog item test-first in the project's real source tree, consistent with its Epic and siblings, and update the docs it changes.

• implement-sql-migration

  Generate the code the SQL migration manifest decided (ScalarDB SQL, schema, Core API and application-side code) as a Gradle module behind an offline gate. Runs after design-sql-migration.

• design

  Design a multi-cloud, four-environment infrastructure: design document, environment matrix and ADRs, no code. Use for "design the infrastructure" or "compare the approaches".

• implement

  Write Terraform, Kubernetes, Helm, Kustomize and CI definitions from an agreed design into a real infrastructure repository. For a scaffold under generated/, use architect:generate-infra-code.

• review

  Review infrastructure code or a design against the platform bundle: ownership overlap, image digest continuity, secret exposure, cloud and environment parity. Use for "review this Terraform".

• start

  Entry point for infrastructure work on AWS, Azure or GCP across local, test, staging and production: fixes the environment and cloud, then routes to design, implement or review. - Bash(${CLAUDE_PLUGIN_ROOT}/tools/update-okf-bundle.sh *) - 'Bash("${CLAUDE_PLUGIN_ROOT}/tools/update-okf-bundle.sh" *)

• init-output

  Create the architect output directories and work/pipeline-progress.json for a new project.

• integrate-evaluations

  Merge the MMI, DDD and, when present, UX evaluations into one prioritized improvement plan.

• investigate-db-design

  Investigate an existing Oracle, PostgreSQL or MySQL database offline, from DDL, schema exports or design documents: structure, relationships, design findings and an ER diagram. - Bash(python3 ${CLAUDE_PLUGIN_ROOT}/skills/common/database-investigation/scripts/investigate.py design *) - 'Bash(python3

• investigate-db-live

  Investigate a live Oracle, PostgreSQL or MySQL database through its catalogs and statistics, read-only, telling unavailable data apart from empty results.

• investigate-security

  Assess an existing system's security posture: OWASP Top 10, access control and zero-trust readiness.

• investigate

  Investigate an existing codebase: technology stack, structure, technical debt and DDD readiness. First step of legacy analysis.

• jdbc-ops

  ScalarDB SQL/JDBC patterns (SELECT, INSERT, UPSERT, UPDATE, DELETE, JOIN, aggregates) with examples, and what ScalarDB SQL does not support.

• local-env

  Set up ScalarDB locally: docker-compose and commands for a dev backend (PostgreSQL, MySQL, Cassandra, DynamoDB Local). Use for "how do I try ScalarDB on my machine".

• map-domains

  Classify an existing system's domains (core, supporting, generic), its business structure and service boundary types, and map the relationships between bounded contexts.

• merge-issue

  Merge an approved Issue's PR/MR after preflight (approvals, CI, conflicts) and confirmation, then close the Issue and roll status up.

• migrate-database

  Move an existing Oracle, MySQL or PostgreSQL database to ScalarDB: schema analysis, migration documents, stored procedures and triggers converted to Java. Use for any database-to-ScalarDB migration.

• migrate-mysql

  MySQL-to-ScalarDB migration: schema extraction, analysis, stored procedure and trigger conversion to Java.

• analyze-mysql-schema

  Analyzes MySQL database schema and generates a comprehensive Markdown report for sharing. Use when you need to document MySQL schema objects including tables, triggers, stored procedures, views, and object dependencies.

• migrate-mysql-sp-trigger-to-scalardb

  Generates ScalarDB Java application code from MySQL stored procedures, functions, and triggers. Produces Java Transaction API implementations plus a summary migration report.

• migrate-mysql-to-scalardb

  Generates ScalarDB migration documentation from MySQL schema analysis. Consumes the MySQL schema analysis Markdown file from the configured output directory as input and produces migration analysis and step-by-step migration guides.

• migrate-oracle

  Oracle-to-ScalarDB migration: schema extraction, analysis, AQ integration, stored procedure and trigger conversion to Java.

• analyze-oracle-schema

  Analyzes Oracle database schema and generates a comprehensive Markdown report for sharing. Use when you need to document Oracle schema objects including tables, triggers, custom types, PL/SQL code, and object dependencies.

• migrate-oracle-aq-to-scalardb

  Generates Oracle AQ setup SQL (payload types, queues, enqueue triggers/SPs) and Java consumer files that dequeue messages and process them using the ScalarDB Java Transaction API.

• migrate-oracle-sp-trigger-to-scalardb

  Generates ScalarDB Java application code from Oracle PL/SQL stored procedures, functions, packages, and triggers. Produces Java Transaction API implementations plus a summary migration report.

• migrate-oracle-to-scalardb

  Generates ScalarDB migration documentation from Oracle schema analysis. Consumes the Oracle schema analysis Markdown file from the configured output directory as input and produces migration analysis and step-by-step migration guides.

• migrate-postgresql

  PostgreSQL-to-ScalarDB migration: schema extraction, analysis, stored procedure and trigger conversion to Java.

• analyze-postgresql-schema

  Analyzes PostgreSQL database schema and generates a comprehensive Markdown report for sharing. Use when you need to document PostgreSQL schema objects including tables, triggers, custom types, PL/pgSQL code, and object dependencies.

• migrate-postgresql-sp-trigger-to-scalardb

  Generates ScalarDB Java application code from PostgreSQL PL/pgSQL functions, procedures, triggers, and trigger functions. Produces Java Transaction API implementations plus a summary migration report.

• migrate-postgresql-to-scalardb

  Generates ScalarDB migration documentation from PostgreSQL schema analysis. Consumes the PostgreSQL schema analysis Markdown file from the configured output directory as input and produces migration analysis and step-by-step migration guides.

• migrate

  Advise on moving between ScalarDB interfaces: Core and Cluster, CRUD and JDBC, one-phase and two-phase commit. To migrate from another database, use architect:migrate-database.

• model

  Design a ScalarDB data model with the user: tables, partition keys, clustering keys and indexes for the access patterns.

• pipeline

  Run every architect pipeline phase in dependency order, unattended, each as a sub-agent; questions are recorded instead of asked.

• adapt-change

  Propagate a change: find the affected artifacts through the traceability graph, confirm them with the user, rerun only those skills and check coherence.

• define-data-model

  Derive the data model from the UI mocks and features, including implicit entities (joins, history, audit, lifecycle) found through a feature x entity CRUD matrix; outputs an ER diagram.

• define-features

  Define features from the UI mocks, one per screen action, reconciled with scope, prioritized with MoSCoW, and traced to a job, journey stage and metric.

• define-nfr

  Turn SLOs into measurable non-functional requirements (availability, p95/p99 latency, throughput, error rate, durability, RPO/RTO), each traced to its SLO.

• define-scope
• define-success-metrics
• define-vision
• design-architecture
• design-positioning
• design-revenue
• design-sla
• design-system
• example-map
• generate-frontend
• generate-persona
• generate-ui-mock
• map-journey
• name-product
• report-status
• report
• research-landscape
• validate-assumptions
• redesign
• render-mermaid
• report-backlog-status
• report-token-cost
• review-api-security
• review-business
• review-code
• review-consistency
• review-data-integrity
• review-issue
• review-operations
• review-report
• review-risk
• review-scalardb
• review-synthesizer
• revise-knowledge
• scaffold
• select-scalardb-edition
• update-knowledge
• verify-implementation
• verify-sql-migration

Hooks (6)

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/validate-mermaid.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/validate-frontmatter.sh

• PostToolUse

  ${CLAUDE_PLUGIN_ROOT}/hooks/validate-frontmatter.sh

• PostToolUse

  python3 ${CLAUDE_PLUGIN_ROOT}/hooks/record_token_usage.py

• Stop

  python3 ${CLAUDE_PLUGIN_ROOT}/hooks/record_token_usage.py

• SubagentStop

  python3 ${CLAUDE_PLUGIN_ROOT}/hooks/record_token_usage.py

Similar plugins