@agile-team/wl-skills-kit

Provides 9 pre-built AI Skill templates that enforce 13 coding standards through a single npm install command. Templates are structured as reusable patterns for Vue 3 projects, with built-in linting rules and code style guidelines that automatically apply to imported skills. The framework uses a convention-over-configuration approach where each skill template includes standardized folder structures, naming conventions, and TypeScript/Vue 3 type definitions.

Exposes 14 pre-configured Model Context Protocol (MCP) tools that integrate with AI editors (Cursor, Windsurf, Kiro) through a standardized tool registry. Each tool is pre-wired with schema definitions, input/output validation, and error handling. The framework manages tool discovery, schema serialization, and protocol-level communication without requiring developers to write MCP boilerplate.

Collects performance metrics for skill execution including latency, error rates, and resource usage. The framework automatically instruments skills to measure execution time, token usage (for AI models), and error frequency. Metrics are exposed via a metrics API and can be exported to monitoring systems like Prometheus or DataDog for dashboarding and alerting.

Automatically generates documentation for skills from their TypeScript definitions, including parameter descriptions, return types, and usage examples. The framework extracts JSDoc comments, type information, and error handling patterns from skill code and generates Markdown documentation that can be published to a documentation site. Documentation is kept in sync with skill definitions through automated generation.

Manages context and state across multiple skill invocations in a conversation or workflow. The framework maintains a context object that persists across skill calls, allowing skills to access previous results, user preferences, and conversation history. Context can be serialized and stored for resuming interrupted workflows, with built-in support for context isolation and cleanup.

Enables developers to compose multiple AI Skills into workflows where outputs from one skill feed into inputs of another. The framework manages skill state, error propagation, and context passing between skills using a pipeline pattern. Skills are registered in a skill registry and can be invoked sequentially or conditionally based on runtime logic, with built-in support for skill dependency resolution.

Enforces TypeScript-based skill definitions where input/output types are declared at definition time and validated at runtime. Each skill is a TypeScript class or function with strict type signatures, and the framework performs schema validation on skill invocation using the declared types. This enables IDE autocomplete, compile-time type checking, and runtime safety without requiring separate schema files.

Automatically exposes installed AI Skills to Cursor, Windsurf, and Kiro editors through a standardized plugin interface. The framework scans the skill registry at editor startup and registers each skill as an available action in the editor's command palette and context menus. Skills are discoverable without manual configuration, and editor context (selected code, file path, project structure) is automatically passed to skills.

Bundles 13 pre-defined coding standards as ESLint/Prettier rules that are automatically applied to all AI Skills in the project. Standards cover naming conventions, file structure, error handling patterns, and TypeScript usage. The framework integrates with the project's existing linting pipeline and can be configured to run on pre-commit hooks or CI/CD pipelines, with detailed violation reports.

Automatically generates JSON Schema definitions from TypeScript skill parameter types, enabling runtime validation and AI model prompt generation. When a skill is defined with TypeScript types, the framework introspects those types and generates corresponding JSON Schemas that describe valid inputs. These schemas are used to validate skill invocations at runtime and can be passed to AI models to guide parameter generation.

Provides built-in error handling patterns for skills including retry logic, fallback skills, and error recovery strategies. Skills can define error handlers that execute when a skill fails, with support for exponential backoff, circuit breaker patterns, and fallback skill invocation. Error context (including the original error, skill parameters, and execution state) is passed to error handlers for intelligent recovery decisions.

Provides testing utilities for skills including mock AI model responses, skill invocation simulators, and assertion helpers. Developers can write unit tests for skills without calling real AI models, using pre-recorded or synthetic responses. The framework includes helpers for asserting skill behavior, validating parameter validation, and testing error handling paths.

Manages skill versions and ensures backward compatibility when skill definitions change. Skills can be versioned independently, and the framework tracks which version of a skill is being used in workflows. When a skill is updated, the framework can detect breaking changes and warn developers, or automatically adapt old skill invocations to new signatures using adapter patterns.