playbooks

home / skills / falkicon / mechanic / k-fencore

k-fencore skill

/.agent/skills/k-fencore

This skill provides pure, testable FenCore utility functions for WoW addons, enabling safe math, table, and environment operations.

npx playbooks add skill falkicon/mechanic --skill k-fencore

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
2.9 KB
---
name: k-fencore
description: >
  Context for FenCore - the pure logic library for WoW addons. Covers
  utility functions, math helpers, table operations, and environment
  detection. Load this when working with FenCore or needing utility functions.
  Triggers: fencore, utility, math, table, logic, pure functions.
---

# FenCore Library

FenCore is a pure logic library for WoW addons - no UI dependencies, just utility functions.

## Design Philosophy

- **Pure Functions**: No side effects, predictable outputs
- **No UI Dependencies**: Works in any layer of your addon
- **Testable**: All functions can be unit tested without WoW
- **Documented**: Every function has clear input/output contracts

## MCP Tools

| Task | MCP Tool |
|------|----------|
| List All Functions | `fencore.catalog()` |
| Search Functions | `fencore.search(query="clamp")` |
| Get Function Details | `fencore.info(domain="Math", function="Clamp")` |

## Domains

FenCore organizes functions by domain:

| Domain | Purpose | Examples |
|--------|---------|----------|
| **Math** | Numeric operations | `Clamp`, `Round`, `Lerp`, `InRange` |
| **Table** | Table manipulation | `Copy`, `Merge`, `Filter`, `Map` |
| **String** | String utilities | `Split`, `Trim`, `StartsWith`, `Format` |
| **Color** | Color manipulation | `HexToRGB`, `RGBToHex`, `Lighten`, `Darken` |
| **Time** | Time formatting | `FormatDuration`, `FormatTime`, `ParseDuration` |
| **Environment** | WoW detection | `IsRetail`, `IsClassic`, `GetExpansion` |

## Usage Pattern

```lua
local FenCore = LibStub("FenCore")

-- Access by domain
local Math = FenCore.Math
local result = Math.Clamp(value, 0, 100)

-- Or direct access
local clamped = FenCore.Math.Clamp(value, 0, 100)
```

## Common Functions

### Math

```lua
FenCore.Math.Clamp(value, min, max)     -- Constrain value to range
FenCore.Math.Round(value, decimals)      -- Round to decimal places
FenCore.Math.Lerp(a, b, t)              -- Linear interpolation
FenCore.Math.InRange(value, min, max)   -- Check if value in range
```

### Table

```lua
FenCore.Table.Copy(tbl)                 -- Shallow copy
FenCore.Table.DeepCopy(tbl)             -- Deep copy
FenCore.Table.Merge(base, override)     -- Merge tables
FenCore.Table.Filter(tbl, predicate)    -- Filter by function
FenCore.Table.Map(tbl, transform)       -- Transform values
```

### Environment

```lua
FenCore.Environment.IsRetail()          -- true if retail client
FenCore.Environment.IsClassic()         -- true if classic client
FenCore.Environment.GetExpansion()      -- "TWW", "Classic", etc.
FenCore.Environment.GetBuildInfo()      -- version, build, date
```

## Best Practices

1. **Use for Core layer** - FenCore belongs in your addon's pure logic layer
2. **Don't wrap unnecessarily** - Call FenCore directly, don't create wrappers
3. **Check domain first** - Use `fencore.search` to find existing functions before writing your own
4. **Prefer pure functions** - If you need state, that belongs in Bridge layer

Overview

This skill provides context and quick reference for FenCore, a pure-logic Lua library used by World of Warcraft addon developers. It highlights available utility domains like Math, Table, String, Color, Time, and Environment, and explains when to load FenCore in your project. Use it to find functions, inspect details, and understand recommended usage patterns for a testable, UI-free core layer.

How this skill works

The skill documents what each FenCore domain exposes and how to access functions either by domain (FenCore.Math) or directly (FenCore.Math.Clamp). It also outlines the built-in MCP tools for listing, searching, and getting function details using fencore.catalog(), fencore.search(), and fencore.info(). Finally, it clarifies that all functions are pure and suitable for unit testing outside the WoW UI.

When to use it

  • When building the pure logic layer of an addon and you need reusable utilities.
  • When you want testable, side-effect-free helpers for math, tables, strings, colors, or time.
  • When detecting client environment (Retail vs Classic) or reading expansion/build info.
  • When searching for common helpers to avoid reimplementing standard operations.
  • When you need consistent shallow/deep table operations or safe value clamping.

Best practices

  • Load FenCore in your core logic layer, not the UI layer, to preserve testability.
  • Call FenCore functions directly; avoid creating redundant wrappers around them.
  • Search existing domains with fencore.search before adding new utilities.
  • Favor pure functions; keep stateful behavior in a separate Bridge or state layer.
  • Use DeepCopy/Copy thoughtfully to avoid unexpected shared references.

Example use cases

  • Clamp player stat values between min and max with FenCore.Math.Clamp before display logic.
  • Merge saved-variables defaults with user overrides using FenCore.Table.Merge.
  • Format and parse durations for tooltips with FenCore.Time.FormatDuration and ParseDuration.
  • Detect client type with FenCore.Environment.IsRetail to gate API calls.
  • Transform data structures using FenCore.Table.Map and Filter prior to rendering.

FAQ

Is FenCore safe to use outside the WoW client for unit tests?

Yes. FenCore is pure logic with no UI dependencies, so functions can be unit tested outside the WoW environment.

How do I find if a helper already exists in FenCore?

Use fencore.search(query) to search domains and fencore.catalog() to list available functions before adding new helpers.