littleblacky/agenticforge/agenticforge-skills

AgentSkill     — base class: instantiate directly or extend
MarkdownSkill  — skill loaded from .md file (no tools, uses body as system prompt)
SkillRegistry  — Map<name, IAgentSkill> with routing description generator
SkillRunner    — framework-independent orchestrator (no Agent base class)
SkillLoader    — directory scanner for SKILL.md / *.skill.md files

---
name: weather                     # kebab-case, unique across all skills
description: Get current weather for any city. Answer temperature, rain, and forecast questions.
triggerHint: When the user asks about weather, temperature, rain, wind, or forecast
---
 
You are a concise weather assistant.
-Always include city name and date in your answer.
-Do NOT answer non-weather questions.
-If data is unavailable, say so clearly.

---
name: code-reviewer
description: Review TypeScript/JavaScript code for bugs, style, and performance issues.
triggerHint: When the user asks to review, check, audit, or improve code quality
visible: true
---
 
# Code Reviewer
 
## Role
You are a senior TypeScript engineer doing a thorough code review.
Focus on correctness first, then performance, then style.
 
## Review Checklist
-[ ] Type safety: no implicit `any`, proper return types
-[ ] Error handling: no unhandled promise rejections
-[ ] Edge cases: null/undefined, empty arrays, empty strings
-[ ] Performance: unnecessary re-renders, N+1 loops, memory leaks
 
## Output Format
1.**Summary** — one sentence overall assessment
2.**Issues** — bulleted list, each with: severity (critical/warning/suggestion), location, fix
3.**Improved code** — rewrite the problematic sections

import { AgentSkill } from "@agenticforge/skills";
import { Tool, type ToolParameter } from "@agenticforge/tools";
// 1. Extend Tool (required — Tool is abstract)
class StockPriceTool extends Tool {
  constructor() {
    super("get-stock-price", "Get real-time stock price for a ticker symbol");
  }
  getParameters(): ToolParameter[] {
    return [{ name: "ticker", type: "string", description: "Stock ticker", required: true, default: null }];
  }
  async run(params: Record<string, unknown>): Promise<string> {
    const ticker = String(params.ticker ?? "");
    return `${ticker}: $${(Math.random() * 200 + 50).toFixed(2)}`;
  }
}
// 2. Pass instances to AgentSkill
const stockSkill = new AgentSkill({
  name: "stock-query",
  description: "Look up real-time stock prices and market data",
  triggerHint: "When the user asks about stock price, market cap, ticker, or shares",
  systemPrompt: "You are a financial data assistant. Report prices clearly with currency.",
  tools: [new StockPriceTool()],
});

import { AgentSkill } from "@agenticforge/skills";
import type { SkillContext, SkillResult } from "@agenticforge/skills";
import type { LLMClient } from "@agenticforge/core";
class TranslatorSkill extends AgentSkill {
  constructor() {
    super({
      name: "translator",
      description: "Translate text between any two languages",
      triggerHint: "When the user wants to translate text or asks 'how do you say X in Y'",
    });
  }
  override async execute(ctx: SkillContext, llm: LLMClient): Promise<SkillResult> {
    const targetLang = ctx.metadata?.targetLang as string ?? "English";
    const messages = [
      { role: "system" as const, content: `Translate to ${targetLang}. Output only the translation.` },
      { role: "user" as const, content: ctx.query },
    ];
    const output = await llm.think(messages);
    return { output };
  }
}

import { SkillLoader, SkillRunner, AgentSkill } from "@agenticforge/skills";
import { LLMClient } from "@agenticforge/core";
const llm = new LLMClient({ provider: "openai", model: "gpt-4o" });
// Load Markdown skills from directory
const mdSkills = await SkillLoader.fromDirectory(".cursor/skills");
// Add TypeScript skills
const runner = new SkillRunner({
  llm,
  skills: [...mdSkills, new TranslatorSkill(), stockSkill],
  fallbackPrompt: "You are a helpful general assistant.",
});
// Auto-route
const result = await runner.run("What is AAPL stock price?");
// Direct call (bypass routing)
const result2 = await runner.runSkill("translator", "Hello world", {
  metadata: { targetLang: "Japanese" },
});
// Pass conversation history
const result3 = await runner.run("Translate that to French", {
  history: [
    { role: "user",      content: "Hello world" },
    { role: "assistant", content: "こんにちは世界" },
  ],
});

project/
  .cursor/skills/
    weather/
      SKILL.md        ← loaded (name: "weather")
      examples.md     ← IGNORED
    code-reviewer/
      SKILL.md        ← loaded
    translator.skill.md ← loaded (flat layout alternative)
    README.md           ← IGNORED

// Load all at once
const registry = await SkillLoader.registryFromDirectory(".cursor/skills");
// Merge multiple sources — toRegistry is NOT async
const r = new SkillRegistry();
SkillLoader.toRegistry(await SkillLoader.fromDirectory(".cursor/skills"), r);
SkillLoader.toRegistry(await SkillLoader.fromDirectory("./skills"), r);
r.register(new TranslatorSkill()); // add TS skill