all publishers

ColdBox

@coldbox source repo

121 published skills · page 1 of 2

  1. ▌
    Coldbox REST API Development · coldbox
    Use this skill when building RESTful APIs in ColdBox using RestHandler, creating CRUD API endpoints, implementing API versioning, handling JWT/bearer token authentication, building structured error responses, using the Response object's fluent builders (setData() message/location, withETag(), withCacheControl()), adding HTTP caching to responses, or creating resource representations with mementos.
    0 repo stars
  2. ▌
    Coldbox Testing Base Classes · coldbox
    Use this skill to understand which ColdBox testing base class to extend for a given test type, configure test bundle annotations (appMapping, configMapping, unloadColdBox, loadColdBox, coldboxAppKey), set up the tests/ harness (Application.cfc, folder structure), or choose between integration testing (BaseTestCase), isolated handler testing (BaseHandlerTest), model unit testing (BaseModelTest), interceptor unit testing (BaseInterceptorTest), and real-browser testing of the running app (BrowserTestCase, BoxLang + bx-playwright).
    0 repo stars
  3. ▌
    Coldbox Interceptor Development · coldbox
    Use this skill when creating ColdBox interceptors for cross-cutting concerns, listening to framework lifecycle events, implementing security checks, logging, CORS, rate limiting, request/response transformation, firing and listening to custom interception points, or detecting whether announce() was short-circuited by a listener.
    0 repo stars
  4. ▌
    Coldbox Scheduled Tasks · coldbox
    Use this skill when creating ColdBox scheduled tasks, building Scheduler.cfc files, registering task frequencies, preventing overlapping runs with withNoOverlaps(), constraining tasks to a time-of-day window with between()/startOnTime()/endOnTime(), managing task life-cycles (before/after/onFailure/onSuccess), checking scheduler state via started/startedAt, using server fixation for clustered apps, or configuring module schedulers.
    0 repo stars
  5. ▌
    Coldbox Testing Handler · coldbox
    Use this skill when testing ColdBox event handlers with execute(), asserting rc/prc collections, verifying view selection and rendered output, mocking relocations, mocking the incoming request body with execute()'s body argument, testing renderData() and getHandlerResults(), setting HTTP methods and headers, injecting mocks into handlers, or using BaseHandlerTest for isolated handler unit tests.
    0 repo stars
  6. ▌
    Coldbox Security Csrf · coldbox
    Use this skill when implementing CSRF (Cross-Site Request Forgery) protection in ColdBox forms, using cbcsrf to generate and validate tokens, adding csrf() tokens to HTML forms, validating tokens in POST/PUT/DELETE handlers, configuring the cbcsrf module, or excluding API routes from CSRF verification.
    0 repo stars
  7. ▌
    Testing Coverage · coldbox
    Use this skill when setting up code coverage analysis for ColdBox/ColdFusion/BoxLang applications, configuring coverage reporting, enabling coverage on the CFML web runner with the coverageEnabled URL parameter (opt-in since TestBox 7.1), integrating coverage with CI pipelines, using TestBox coverage options, interpreting coverage metrics, or improving test coverage of untested code paths.
    0 repo stars
  8. ▌
    Coldbox Cache Integration · coldbox
    Use this skill when implementing caching inside a ColdBox application -- configuring CacheBox via ColdBox.cfc or config/CacheBox.cfc, injecting caches with WireBox (cachebox:name), using getCache() in handlers, event output caching with action cache annotations (including etag/etagWeak/lastModified/cacheControl auto-computed HTTP caching), route-level cache rules with Router.withCache(), view fragment caching with renderView(cache=true), query caching, cache listeners as ColdBox interceptors, engine-native providers (BoxLangColdBoxProvider, LuceeColdBoxProvider, CFColdBoxProvider), Redis/distributed provider setup, or choosing between default and template caches.
    0 repo stars
  9. ▌
    Coldbox Module Development · coldbox
    Use this skill when creating reusable ColdBox modules, writing ModuleConfig.cfc, defining module-specific routes, models, settings, and interceptors, packaging modules for ForgeBox, or building internal application sub-systems as modules.
    0 repo stars
  10. ▌
    Coldbox Routing Development · coldbox
    Use this skill when configuring ColdBox routes, setting up RESTful resource routes, creating route groups, implementing URL pattern matching with constraints, defining named routes, answering a route inline with a toResponse() closure, attaching route-scoped middleware with .middleware()/middlewareGroup()/registerMiddleware()/.withoutMiddleware(), sharing route metadata through a group() meta option, declaring route-level cache rules with Router.withCache(), streaming a route with Router.toSSE(), exposing BoxLang AI surfaces with the toAi(), toMCP() and toAiGateway() route terminators, or working with Router.cfc in a ColdBox application.
    0 repo stars
  11. ▌
    Coldbox Testing Integration · coldbox
    Use this skill when writing integration tests for ColdBox that use real dependencies (database, WireBox, ColdBox context), testing full request/response cycles with execute(), setting up and tearing down test databases, testing services with real data, or using BaseTestCase for end-to-end handler tests with actual WireBox injections.
    0 repo stars
  12. ▌
    Cachebox Standalone · coldbox
    Use this skill when working with CacheBox as a standalone caching framework (outside ColdBox) -- installing, creating and bootstrapping the CacheFactory, configuring the DSL, choosing object stores and eviction policies, selecting cache providers (CacheBoxProvider, BoxLang, CF, Lucee), implementing cache-aside/stampede-protection patterns, registering standalone listeners, named caches, disk/JDBC stores, reaping, shutdown, or monitoring cache performance.
    0 repo stars
  13. ▌
    Testbox Bdd · coldbox
    Use this skill when writing BDD-style tests with TestBox using describe/it blocks, feature/story/scenario/given/when/then Gherkin-style suites, lifecycle hooks (beforeAll/afterAll/beforeEach/afterEach/aroundEach), focused specs (fit/fdescribe), skipping specs (xit/xdescribe/skip()) or whole test classes with the class-level skip annotation, engine detection helpers (isBoxLang/isLucee/isAdobe), grouped assertions with assertAll(), collection expectations (expectAll/expectAny/expectSome/expectNone), spec data binding, retrying flaky specs (it/fit/xit retries argument, retries bundle annotation), attaching files to a spec with attach(), asyncAll parallel specs, nested suite trees, labels, or organizing tests around behavior descriptions.
    0 repo stars
  14. ▌
    Testbox Unit Xunit · coldbox
    Use this skill when writing xUnit-style tests in TestBox using test functions (testXxx()), setup/teardown lifecycle (beforeTests/afterTests/setup/teardown), the $assert assertion object, grouped assertions with $assert.all() / assertAll(), retrying flaky tests with the retries method or bundle annotation, attaching files with attach(), skipping a single test or an entire test class with the class-level skip annotation, engine detection helpers (isBoxLang/isLucee/isAdobe), or the Arrange-Act-Assert (AAA) pattern for unit testing services, models, and utilities in isolation.
    0 repo stars
  15. ▌
    Cbcsrf · coldbox
    Use this skill when adding CSRF protection to ColdBox/BoxLang applications with the cbcsrf module. Covers token generation, form helpers, AJAX/meta-tag patterns, manual handler validation, route exemptions, SPA integration, token rotation, and configuration best practices for preventing cross-site request forgery.
    0 repo stars
  16. ▌
    Rulebox · coldbox
    Use this skill when writing business rules with RuleBox, the natural-language rules engine for BoxLang and ColdBox. Covers RuleBook classes and defineRules(), the given/when/except/then/using/ withPriority/stop/active/withDescription DSL, facts and the Result object, declaring and enforcing the facts a RuleBook takes (defineFacts, fact(), withFacts, enforceFacts, strictFacts, validateFacts), describing rulebooks and rules, the Builder, declared rulebooks (ruleBook( "name" ), inject="rulebook:name"), loading rules from JSON, YAML or a database with the condition grammar and registered actions/predicates, the audit trail, dryRun(), rule metrics, error handling, thread safety, the Rule Visualizer, and testing rulebooks with TestBox.
    0 repo stars
  17. ▌
    Testbox Mockbox · coldbox
    Use this skill when creating mocks, stubs, and spies in TestBox using MockBox: createMock(), createEmptyMock(), prepareMock(), stubbing methods with $(), chaining $args()/$results()/$throws() (including order-independent struct matching and BoxLang Set/Range arguments), verifying call counts with $once()/$never()/$times()/$atLeast()/$atMost(), reading call logs with $callLog(), injecting mock properties with $property(), simulating queries with querySim(), or spying on real methods with $spy().
    0 repo stars
  18. ▌
    Testbox Runners · coldbox
    Use this skill when running TestBox tests: CommandBox CLI (testbox run), BoxLang CLI (./testbox/run), HTML web runner, programmatic TestBox instantiation (run/runRaw/runRemote), configuring test directories or bundles, using the streaming runner (--stream flag / StreamingRunner), watcher mode, all CLI flags (--show-failed-only, --dry-run, --slow-threshold-ms, --stacktrace, --max-failures), toggling code coverage with the coverageEnabled URL parameter (opt-in since TestBox 7.1), retrying failing specs (--retries), rerunning only the last failures (--failed), starting a web server for browser tests (--web-server, --web-server-url, --web-server-timeout), or setting up box.json testbox configuration.
    0 repo stars
  19. ▌
    Testbox Reporters · coldbox
    Use this skill when selecting or configuring TestBox reporters: Agent, ANTJunit, Console, Doc, Dot, JSON, JUnit, Min, MinText, Simple, Text, XML, Streaming; the TestBox 7.2 HTML reporters (Simple, Min, Dot, Doc) with light/dark themes, keyboard shortcuts, status filters and Ask AI (aiAssist, aiProviders, aiContextLines, aiStackFrames, aiPrompt, urlParams); editor links; setting reporter options (hideSkipped); how reporters show spec attachments (attach(), browser screenshots/traces/videos) and retry attempts; or creating a custom reporter by implementing the IReporter interface.
    0 repo stars
  20. ▌
    Cbsecurity · coldbox
    Use this skill when securing ColdBox/BoxLang applications with cbsecurity. Covers firewall rule configuration, annotation-based security on handlers/actions, JWT authentication, role and permission checks, route middleware (Authenticated, Authorized, JwtAuth, BasicAuth, Throttle, ApiKey, AllowedIPs, DenyIPs, EnsureHttps, VerifyCsrf, Honeypot, Signed), signed URLs, security context helpers, custom validators, interceptor events, and production hardening patterns.
    0 repo stars
  21. ▌
    Testbox Assertions · coldbox
    Use this skill when using the TestBox $assert object for xUnit-style assertions: isTrue, isFalse, isTruthy, isFalsy, isEqual, isSameInstance, includes, includesAll, includesAny, includesNone, isEmpty, key, deepKey, instanceOf, throws, between, closeTo, lengthOf, match, null, typeOf, isJSON and others; grouping assertions with $assert.all() / assertAll() so every failure is reported at once; registering custom assertion functions with addAssertions(); or using BoxLang dynamic assertion methods (assertIsTrue, assertBetween, etc.).
    0 repo stars
  22. ▌
    Coldbox Event Model · coldbox
    Use this skill when working with the ColdBox event object (prc/rc), managing request collections, rendering views and data responses, handling redirects with relocate(), controlling HTTP status codes, or implementing event caching in ColdBox handlers.
    0 repo stars
  23. ▌
    Testbox Expectations · coldbox
    Use this skill when writing fluent expectations in TestBox using expect(), the collection modes (expectAll, expectAny, expectSome, expectNone), expectation context with withContext(), and the built-in matchers: toBe, toBeTrue, toBeFalse, toBeTruthy, toBeFalsy, toBeNull, toBeArray, toBeStruct, toBeEmpty, toHaveLength, toHaveSize, toBeTypeOf, toBeInstanceOf, toBeSameInstanceAs, toHaveKey, toHaveDeepKey, toInclude, toIncludeWithCase, toIncludeAll, toIncludeAny, toIncludeNone, toMatch, toBeGT, toBeGTE, toBeLT, toBeLTE, toBeBetween, toBeCloseTo, toSatisfy, toThrow, toThrowMatching; the BoxLang-only Set matchers (toBeASet, toEqualSet, toBeSubsetOf, toBeSupersetOf, toBeDisjointFrom, toHaveUnion, toHaveIntersection, toHaveDifference, toHaveSymmetricDifference); the BoxLang-only Range matchers (toBeRange, toContainValue, toContainRange, toBeInRange, toBeBeforeRange, toBeAfterRange, toBeBounded, toBeUnbounded, toBeHalfBounded, toBeIterable, toBeAscending, toBeDescending, toHaveStep, toClampTo); the BoxLang-only Data Na
    0 repo stars
  24. ▌
    Coldbox Configuration · coldbox
    Use this skill when configuring a ColdBox application in ColdBox.cfc, setting up environments, managing module settings, defining datasources, configuring logging with LogBox, setting up caching with CacheBox, or wiring dependencies with WireBox settings.
    0 repo stars
  25. ▌
    Coldbox AI Integration · coldbox
    Use this skill when integrating AI capabilities into a ColdBox application using the BoxLang AI library (bx-ai module) -- including simple chat, streaming (see coldbox-sse-streaming for first-class SSE), pipelines, agents, RAG with vector memory, document loading, tool calling, auto-scaffolding a REST API for an IAiRunnable with route( ... ).toAi(), exposing an AI Gateway over HTTP with route( ... ).toAiGateway() for platform webhooks and human-in-the-loop approvals, and injecting the AI service into handlers or models.
    0 repo stars
  26. ▌
    Coldbox View Rendering · coldbox
    Use this skill when rendering views and partials in ColdBox, creating reusable view components, caching view output, passing data to views, rendering views from services, using renderView() inline, or dynamically selecting views based on context.
    0 repo stars
  27. ▌
    Coldbox Request Context · coldbox
    Use this skill when working with the ColdBox RequestContext object (event), managing rc and prc collections, building URLs with buildLink(), detecting HTTP methods, reading the original un-spoofed HTTP verb with getOriginalHTTPMethod(), setting HTTP caching primitives (etag/lastModified/cacheControl), accessing request metadata, working with flash scope, handling AJAX requests, or reading HTTP headers and body content.
    0 repo stars
  28. ▌
    Coldbox Testing Browser · coldbox
    Use this skill when writing browser tests for a ColdBox application with coldbox.system.testing.BrowserTestCase (BoxLang + bx-playwright): choosing browser tests vs BaseTestCase integration tests, browse() with isolated pages, the baseURL and browserProfile annotations, this.playwright(), browserAvailable() and browserUnavailableReason(), the named route helpers routeURL(), visitRoute() and assertRouteIs() (with or without params, name@module and module:name routes), logging users in and out with loginAs() and logout() through the test-only BrowserTesting core module (moduleSettings.browserTesting enabled/token/login/logout, X-Browser-Testing-Token header, testing environment only, 404 otherwise), running the app server for the browser (CommandBox server or TestBox --web-server), and CI setup.
    0 repo stars
  29. ▌
    Testbox Browser Testing · coldbox
    Use this skill when writing or running browser tests with TestBox on BoxLang: extending testbox.system.BrowserSpec, installing bx-playwright and Chromium (install-bx-module bx-playwright, bxPlaywright install), the browserProfile and baseURL class annotations, browse() with one isolated page per callback argument, this.playwright() and browserAvailable(), the browser matchers (toHaveTitle, toHaveURL, toHavePath, toSee, toHaveText, toBeVisible, toBeHidden, toHaveCount, toHaveValue and their not forms), automatic screenshot/trace/video attachments, attach(), spec retries (it retries argument, retries bundle or method annotation, --retries), rerunning failures with --failed, starting the app with --web-server/--web-server-url/--web-server-timeout, CI setup, and debugging failed browser specs with bxPlaywright show-trace.
    0 repo stars
  30. ▌
    Coldbox Sse Streaming · coldbox
    Use this skill when streaming Server-Sent Events (SSE) from a ColdBox handler or route with event.sse(), building a route that always streams with Router.toSSE(), sending data/events/errors through an SSEEmitter, reacting to SSE connect/disconnect/error via the preSSEConnection/postSSEConnection/onSSEError interception points, or configuring the this.sse settings block (keep-alive interval, reconnect hints, CORS defaults).
    0 repo stars
  31. ▌
    Coldbox Layout Development · coldbox
    Use this skill when creating ColdBox layouts (master page templates), building admin layouts, creating reusable view partials, implementing nested content rendering with renderView(), switching layouts dynamically per handler, or organizing HTML structure around content views.
    0 repo stars
  32. ▌
    Contentbox Cfml Multi Site · coldbox
    Use this skill when implementing or maintaining ContentBox multi-site setups, including domain/site resolution, site-specific content and themes, settings isolation, menu behavior, and operational best practices.
    0 repo stars
  33. ▌
    Commandbox Boxlang · coldbox
    Use this skill when configuring CommandBox to run BoxLang server instances, using the BoxLang REPL, running BoxLang task runners, and managing BoxLang modules via CommandBox. Covers server.json BoxLang configuration, CLI commands, module installation, and the BoxLang-specific CommandBox workflow.
    0 repo stars
  34. ▌
    Database Migrations · coldbox
    Use this skill when managing database schema changes in ColdBox/BoxLang using cfmigrations and commandbox-migrations. Covers migration file structure, Schema Builder API, seeding, and CLI workflows for creating, running, and rolling back migrations safely.
    0 repo stars
  35. ▌
    Coldbox Handler Development · coldbox
    Use this skill when creating ColdBox handlers (controllers), implementing CRUD actions, adding dependency injection to handlers, working with preHandler/postHandler advices, secured actions, REST handlers, or the EventHandler base class.
    0 repo stars
  36. ▌
    Coldbox Testing Interceptor · coldbox
    Use this skill when unit testing ColdBox interceptors in isolation using BaseInterceptorTest, accessing the pre-wired interceptor variable, leveraging mock helpers (mockController, mockRequestService, mockLogger, mockLogBox, mockFlash), configuring interceptor properties with configProperties, calling interceptor announce points directly, or scaffolding interceptor tests with CommandBox.
    0 repo stars
  37. ▌
    Contentbox Boxlang Overview · coldbox
    Use this skill when understanding ContentBox architecture, core modules, service layer, multi-site behavior, security foundations, and the recommended extension points for building or maintaining ContentBox solutions.
    0 repo stars
  38. ▌
    Cbsecurity Passkeys · coldbox
    Use this skill when implementing WebAuthn/Passkeys authentication in ColdBox/BoxLang using the cbsecurity-passkeys module. Covers the credential repository interface, registration ceremony, authentication ceremony, JavaScript integration, and production hardening for passwordless login.
    0 repo stars
  39. ▌
    Coldbox Security API Authentication · coldbox
    Use this skill when implementing API key authentication in ColdBox REST APIs, generating and validating API keys, caching API key lookups with CacheBox, implementing bearer token middleware, managing API key scopes and revocation, or adding an API key interceptor to protect REST endpoints.
    0 repo stars
  40. ▌
    Coldbox Testing HTTP Methods · coldbox
    Use this skill when simulating HTTP requests in ColdBox tests using the get(), post(), put(), patch(), delete(), or request() methods, setting request headers (Authorization, Accept, Content-Type), sending JSON request bodies, asserting response status with toHaveStatus(), checking validation errors with toHaveInvalidData(), or understanding the difference between execute() (event-based) and the HTTP method helpers (route/URL-based).
    0 repo stars
  41. ▌
    Contentbox Cfml API Headless · coldbox
    Use this skill when implementing headless ContentBox APIs, including REST endpoint design, JWT authentication flows, content CRUD, custom API handlers, and integration patterns for decoupled frontends.
    0 repo stars
  42. ▌
    Contentbox Boxlang Multi Site · coldbox
    Use this skill when implementing or maintaining ContentBox multi-site setups, including domain/site resolution, site-specific content and themes, settings isolation, menu behavior, and operational best practices.
    0 repo stars
  43. ▌
    Contentbox Cfml Content Types · coldbox
    Use this skill when implementing ContentBox content models and rendering flows, including entries/pages/content stores, custom fields, entity relationships, lifecycle callbacks, and content-type specific behaviors.
    0 repo stars
  44. ▌
    Commandbox Migrations · coldbox
    Use this skill when running database migrations from the CommandBox CLI using commandbox-migrations, including migrate up/down/reset/refresh, creating migration files, running seeders, and checking migration status. Covers CI/CD usage, configuration, and all CLI commands for cfmigrations.
    0 repo stars
  45. ▌
    Coldbox Security Passkeys · coldbox
    Use this skill when implementing passkeys (WebAuthn/FIDO2) passwordless authentication in ColdBox with cbsecurity-passkeys, configuring relying party settings, building passkey registration and authentication flows, managing passkey device storage, or adding biometric and hardware security key login support.
    0 repo stars
  46. ▌
    Contentbox Boxlang API Headless · coldbox
    Use this skill when implementing headless ContentBox APIs, including REST endpoint design, JWT authentication flows, content CRUD, custom API handlers, and integration patterns for decoupled frontends.
    0 repo stars
  47. ▌
    Contentbox Cfml Admin Extension · coldbox
    Use this skill when extending the ContentBox admin UI with custom menus, views, interception points, editor integrations, workflows, and secure admin-only module behaviors.
    0 repo stars
  48. ▌
    Contentbox Boxlang Content Types · coldbox
    Use this skill when implementing ContentBox content models and rendering flows, including entries/pages/content stores, custom fields, entity relationships, lifecycle callbacks, and content-type specific behaviors.
    0 repo stars
  49. ▌
    Contentbox Cfml Media Management · coldbox
    Use this skill when implementing ContentBox media workflows, including uploads, storage abstraction with cbfs, image handling/resizing, media delivery patterns, and governance/security controls for assets.
    0 repo stars
  50. ▌
    Coldbox Security Implementation · coldbox
    Use this skill when setting up the full CBSecurity framework in ColdBox, configuring the security firewall, creating authentication services, implementing security event handlers, configuring security rules and validators, or building a complete security layer for a ColdBox application.
    0 repo stars
  51. ▌
    Contentbox Cfml Theme Development · coldbox
    Use this skill when creating or customizing ContentBox themes, including theme structure, metadata/settings, layout and view composition, collection templates, widget overrides, and theme lifecycle callbacks.
    0 repo stars
  52. ▌
    Contentbox Boxlang Admin Extension · coldbox
    Use this skill when extending the ContentBox admin UI with custom menus, views, interception points, editor integrations, workflows, and secure admin-only module behaviors.
    0 repo stars
  53. ▌
    Contentbox Cfml Module Development · coldbox
    Use this skill when building ContentBox modules, including ModuleConfig conventions, admin integration, interceptors, routes, migrations, ORM entities, dependency registration, and module lifecycle hooks.
    0 repo stars
  54. ▌
    Contentbox Cfml Widget Development · coldbox
    Use this skill when building ContentBox widgets, including BaseWidget patterns, render logic, dependency injection, editor metadata annotations, caching choices, and safe output/rendering practices.
    0 repo stars
  55. ▌
    Contentbox Boxlang Media Management · coldbox
    Use this skill when implementing ContentBox media workflows, including uploads, storage abstraction with cbfs, image handling/resizing, media delivery patterns, and governance/security controls for assets.
    0 repo stars
  56. ▌
    Contentbox Boxlang Theme Development · coldbox
    Use this skill when creating or customizing ContentBox themes, including theme structure, metadata/settings, layout and view composition, collection templates, widget overrides, and theme lifecycle callbacks.
    0 repo stars
  57. ▌
    Contentbox Cfml Security Permissions · coldbox
    Use this skill when implementing ContentBox security and permissions, including roles, permission modeling, cbSecurity integration, authorization checks, CSRF/rate-limiting protections, and hardening patterns.
    0 repo stars
  58. ▌
    Contentbox Boxlang Module Development · coldbox
    Use this skill when building ContentBox modules, including ModuleConfig conventions, admin integration, interceptors, routes, migrations, ORM entities, dependency registration, and module lifecycle hooks.
    0 repo stars
  59. ▌
    Contentbox Boxlang Widget Development · coldbox
    Use this skill when building ContentBox widgets, including BaseWidget patterns, render logic, dependency injection, editor metadata annotations, caching choices, and safe output/rendering practices.
    0 repo stars
  60. ▌
    Contentbox Boxlang Security Permissions · coldbox
    Use this skill when implementing ContentBox security and permissions, including roles, permission modeling, cbSecurity integration, authorization checks, CSRF/rate-limiting protections, and hardening patterns.
    0 repo stars
  61. ▌
    Contentbox Cfml Two Factor Authentication · coldbox
    Use this skill when implementing or customizing ContentBox two-factor authentication providers, trusted device flows, enrollment/verification UX, enforcement policies, and provider lifecycle handling.
    0 repo stars
  62. ▌
    Contentbox Boxlang Two Factor Authentication · coldbox
    Use this skill when implementing or customizing ContentBox two-factor authentication providers, trusted device flows, enrollment/verification UX, enforcement policies, and provider lifecycle handling.
    0 repo stars
  63. ▌
    Logbox · coldbox
    Use this skill whenever working with LogBox -- standalone or inside a ColdBox application. Covers installation, configuration DSL (appenders, root logger, categories), all built-in appender types with their properties, logger injection via WireBox DSL, category inheritance, structured logging with extraInfo, performance patterns (can{} methods, closure messages), custom appenders, custom layouts, async logging, environment-specific config, and production best practices.
    0 repo stars
  64. ▌
    Wirebox Di · coldbox
    Use this skill when working with WireBox dependency injection -- bootstrapping the injector, configuring binders, creating object mappings, using the injection DSL, setting persistence scopes, applying providers to avoid scope-widening, lazy properties, property observers, object delegation, virtual inheritance, child injectors, the object populator, or WireBox event listeners. Applies to both standalone and ColdBox-integrated usage.
    0 repo stars
  65. ▌
    Qb · coldbox
    Use this skill when building database queries with qb (Query Builder) in ColdBox/BoxLang. Covers QueryBuilder injection, select/from/where/join/group/order/limit clauses, aggregates, inserts, updates, deletes, raw expressions, sub-queries, chunking, and grammar configuration for MySQL, Postgres, MSSQL, and SQLite.
    0 repo stars
  66. ▌
    Cbq · coldbox
    Use this skill when implementing asynchronous background job processing in ColdBox/BoxLang with cbq. Covers job class creation, queue configuration (database, Redis, SQS), dispatching jobs, delayed dispatch, queue routing, retry handling, worker pool management, and monitoring patterns.
    0 repo stars
  67. ▌
    Cbfs · coldbox
    Use this skill when working with the cbfs file system abstraction module in ColdBox/BoxLang applications. Covers installation, disk configuration (local, S3, RAM, FTP), CRUD file operations, streaming, URL generation, file uploads, directory listing, and multi-provider patterns for different environments.
    0 repo stars
  68. ▌
    Cors · coldbox
    Use this skill when configuring Cross-Origin Resource Sharing (CORS) for ColdBox/BoxLang REST APIs using the cors module. Covers allowed origins, methods, headers, credentials, preflight OPTIONS handling, dynamic origin functions, and production hardening.
    0 repo stars
  69. ▌
    Cborm · coldbox
    Use this skill when working with Hibernate ORM in ColdBox/BoxLang using the cborm module. Covers BaseORMService, VirtualEntityService, the Criteria Builder (restrictions, projections, joins, sub-queries, pagination), transaction management, event interceptions, and production patterns for data access layers.
    0 repo stars
  70. ▌
    Cbsso · coldbox
    Use this skill when implementing Single Sign-On (SSO) in ColdBox/BoxLang using the cbsso module. Covers SAML2 and OAuth2/OIDC configuration, the SSOService API, redirect-to-provider flow, callback processing, token validation, user provisioning on first login, and session management.
    0 repo stars
  71. ▌
    Hyper · coldbox
    Use this skill when making HTTP requests from ColdBox/BoxLang applications using the Hyper HTTP client. Covers HyperBuilder injection, fluent request construction, GET/POST/PUT/DELETE shortcuts, headers, authentication, timeout configuration, response handling, error handling, and production patterns for REST API integrations.
    0 repo stars
  72. ▌
    Quick · coldbox
    Use this skill when building Active Record-style database entities with Quick ORM in ColdBox, CFML, or BoxLang applications. Covers entity metadata, safe persistence, relationships, query scopes, eager loading, serialization, soft deletes, lifecycle events, and service boundaries.
    0 repo stars
  73. ▌
    Relax · coldbox
    Use this skill when modeling REST APIs with the Relax DSL, defining routes with parameters and response schemas, generating API documentation, and producing JSON/XML specification output for ColdBox-based REST services.
    0 repo stars
  74. ▌
    S3sdk · coldbox
    Use this skill when working with Amazon S3 (or S3-compatible storage) in ColdBox/BoxLang using the s3sdk module. Covers injection, bucket operations, object upload/download/delete, presigned URLs, metadata, ACLs, multipart uploads, and integration with cbfs or direct usage.
    0 repo stars
  75. ▌
    Bcrypt · coldbox
    Use this skill when working with BCrypt password hashing in ColdBox/BoxLang applications. Covers installation, work-factor configuration, hashing passwords, verifying credentials, generating salts, mixin helpers in handlers/interceptors, user registration, authentication, password change/reset, and security best practices for credential handling.
    0 repo stars
  76. ▌
    Cbauth · coldbox
    Use this skill when implementing user authentication with the cbauth module in ColdBox/BoxLang applications. Covers installation, IUserService and IAuthUser interfaces, session-based login/logout, manual login, authentication checks, CBStorages integration, Flash RAM messaging, and security patterns for credential handling.
    0 repo stars
  77. ▌
    Cbi18n · coldbox
    Use this skill when adding internationalization (i18n) and localization (l10n) to a ColdBox/BoxLang application with the cbi18n module. Covers installation, resource bundle formats (.properties and JSON), locale management, translation helpers ($r / getResource), positional and named substitutions, multiple bundles, locale switching, and date/number formatting.
    0 repo stars
  78. ▌
    Cbwire · coldbox
    Use this skill when building reactive UI components in ColdBox/BoxLang with cbwire, a Livewire-inspired library. Covers wire components and templates, wire:model and wire:click directives, lifecycle hooks, computed properties, events, validation, file uploads, lazy loading, JavaScript integration, and the behavior traps that are hard to diagnose.
    0 repo stars
  79. ▌
    Coldbox Logging · coldbox
    Use this skill for all ColdBox-specific logging concerns: configuring LogBox inside a ColdBox application (config/LogBox.cfc, inline DSL, configFile pointer), per-environment log levels, injecting loggers into handlers/interceptors/services via the WireBox logbox DSL, accessing logbox from the ColdBox proxy, and logging best practices specific to the ColdBox lifecycle.
    0 repo stars
  80. ▌
    Cbfeeds · coldbox
    Use this skill when reading or generating RSS/Atom feeds in ColdBox/BoxLang using cbfeeds. Covers FeedReader for consuming external feeds, FeedGenerator for producing RSS 2.0 and Atom feeds, caching parsed feeds, and rendering feed XML from ColdBox handlers.
    0 repo stars
  81. ▌
    Cbproxies · coldbox
    Use this skill when creating dynamic Java-compatible proxies of ColdBox/BoxLang components using cbproxies. Covers ProxyFactory injection, creating proxies for Java interfaces, lazy-loading components, method interception, and integration with Java frameworks that require interface implementations (JDBC, Hibernate, Java threading, etc.).
    0 repo stars
  82. ▌
    Cbswagger · coldbox
    Use this skill when generating OpenAPI 3.x (Swagger) documentation for ColdBox/BoxLang REST APIs using cbswagger. Covers installation, module configuration, handler/action JSDoc annotations, request/response schemas, security definitions, parameter documentation, and accessing the generated spec.
    0 repo stars
  83. ▌
    Socketbox · coldbox
    Use this skill when building WebSocket features with SocketBox in ColdBox/CFML/BoxLang. Covers the real SocketBox APIs for core WebSocket handling and STOMP broker usage, including correct base classes, method signatures, server-side sends, and client examples.
    0 repo stars
  84. ▌
    Testbox Listeners · coldbox
    Use this skill when implementing TestBox run listeners (callbacks): onBundleStart, onBundleEnd, onSuiteStart, onSuiteEnd, onSpecStart, onSpecEnd; building progress indicators, custom loggers, or live dashboards that react to test lifecycle events; or passing listener callbacks to TestBox's run(), runRaw(), or the standalone runner.
    0 repo stars
  85. ▌
    Coldbox Decorators · coldbox
    Use this skill when extending or overriding ColdBox framework internals via the Decorator pattern -- specifically creating a ControllerDecorator to wrap the main ColdBox controller, or a RequestContextDecorator to wrap and augment the request context (event) object with custom methods or overridden behavior.
    0 repo stars
  86. ▌
    Coldbox Di · coldbox
    Use this skill when working with dependency injection inside a ColdBox application -- the ColdBox injection DSL namespaces (coldbox:, logbox:, cachebox:, wirebox:, model:), module settings injection, injecting ColdBox services (interceptors, flash, router, scheduler), configuring the WireBox binder in ColdBox context, the enhanced ColdBox binder helpers, or wiring handlers/interceptors/models via ColdBox-aware WireBox.
    0 repo stars
  87. ▌
    Cbantisamy · coldbox
    Use this skill when sanitizing HTML/XML user input to prevent XSS attacks using the OWASP AntiSamy library via the cbantisamy module. Covers installation, policy selection (strict/relaxed/slashdot/ebay/myspace), custom XML policy files, fluent sanitization API, ColdBox validation integration, and safe rendering of rich user-generated HTML.
    0 repo stars
  88. ▌
    Cbdebugger · coldbox
    Use this skill when installing, configuring, or using the CBDebugger visual debugging panel in a ColdBox application. Covers enabling the panel in development, performance profiling, SQL query tracking, cache monitoring, request inspection, and ensuring the debugger is disabled in production.
    0 repo stars
  89. ▌
    Cbmarkdown · coldbox
    Use this skill when converting Markdown to HTML in a ColdBox/BoxLang application using the cbmarkdown module. Covers installation, injecting the Processor, converting Markdown strings to HTML, using in views, supported syntax (GFM, tables, code blocks), and security considerations for user-generated Markdown.
    0 repo stars
  90. ▌
    Cbmockdata · coldbox
    Use this skill when generating realistic fake seed/test data in ColdBox/BoxLang using the cbmockdata module. Covers installation, the mock() API, built-in data types, entity population, testing integration, and bulk generation patterns for prototyping and test suites.
    0 repo stars
  91. ▌
    Cbstorages · coldbox
    Use this skill when persisting data across requests in ColdBox/BoxLang using cbstorages. Covers Session, Cookie, Cache, Request, and Application storage adapters; configuration; get/set/exists/ delete/clear operations; encryption; TTLs; and patterns for shopping carts, user preferences, and API token caching.
    0 repo stars
  92. ▌
    Unleashsdk · coldbox
    Use this skill when implementing feature flags and gradual rollouts in ColdBox/BoxLang using the unleashsdk module. Covers UnleashClient configuration, isEnabled() checks, getVariant() for A/B testing, custom context, gradual rollout strategies, and production patterns for safe feature releases.
    0 repo stars
  93. ▌
    Testbox Cbmockdata · coldbox
    Use this skill when generating realistic fake/mock data in tests using cbMockData (WireBox ID: MockData@cbMockData): age, boolean, date, datetime, email, fname, lname, name, num, sentence, ssn, string, tel, uuid, url, words, lorem, baconlorem, imageurl, ipaddress, autoincrement, oneof, rnd/rand; generating arrays of objects, nested objects, arrays of values, or using custom supplier closures.
    0 repo stars
  94. ▌
    Coldbox App Layouts · coldbox
    Use this skill when choosing a ColdBox application layout (flat, boxlang, or modern), scaffolding a new ColdBox project, understanding project directory structure, deciding between app structure options, or migrating from one layout to another. Use when asked about flat layout, boxlang template, modern template, app structure, project skeleton, or web root separation.
    0 repo stars
  95. ▌
    Coldbox CLI · coldbox
    Use this skill when using the ColdBox CLI (CommandBox module) to scaffold applications, generate handlers, models, services, views, layouts, interceptors, modules, ORM artifacts, tests, or manage AI integration. Covers all `coldbox create` commands, language flags (BoxLang vs CFML), app skeleton selection, feature flags (--docker, --vite, --rest, --migrations, --ai), template token patterns, layout detection, and AI integration sub-commands.
    0 repo stars
  96. ▌
    Wirebox Aop · coldbox
    Use this skill when working with WireBox Aspect-Oriented Programming (AOP) -- activating the AOP engine (Mixer listener), creating method interceptor aspects, registering aspects via mapAspect(), binding aspects to classes and methods via bindAspect(), using the Matcher DSL (any, regex, mappings, instanceOf, annotatedWith, methods, returns), auto-aspect binding via classMatcher/methodMatcher annotations, the MethodInvocation API (proceed, getArgs, getTarget, getMethod), using built-in aspects (CFTransaction, HibernateTransaction, MethodLogger), and AOP in both standalone WireBox and ColdBox applications.
    0 repo stars
  97. ▌
    Cbpaginator · coldbox
    Use this skill when implementing server-side pagination in ColdBox/BoxLang using cbpaginator. Covers installation, Paginator service configuration, generating pagination metadata for APIs and views, integrating with QB QueryBuilder, rendering Bootstrap pagination controls, and building pageable collection responses.
    0 repo stars
  98. ▌
    Mementifier · coldbox
    Use this skill when serializing ColdBox/BoxLang ORM entities or model objects to structs/JSON using mementifier. Covers this.memento configuration, getMemento() usage, defaultIncludes/ defaultExcludes/neverInclude, computed properties via mappers, relationship serialization, named profiles, and production API response patterns.
    0 repo stars
  99. ▌
    Cbjavaloader · coldbox
    Use this skill when dynamically loading Java JAR libraries at runtime in a ColdBox application using cbjavaloader. Covers installation, classpath configuration, creating Java objects from JARs, reloading in development, and common use cases (PDF processing, Apache POI, image manipulation).
    0 repo stars
  100. ▌
    Cbmessagebox · coldbox
    Use this skill when displaying flash-scope messages (info, success, warning, error) in ColdBox/BoxLang views using the cbmessagebox module. Covers installation, setting messages in handlers, rendering in views/layouts, checking for messages, clearing messages, and Bootstrap-compatible output patterns.
    0 repo stars