@kevinrabun/judges 3.115.0 → 3.115.1

package/dist/agent-loader.d.ts

@@ -0,0 +1,107 @@
+/**
+ * Agent Markdown Loader — reads `.judge.md` files (legacy `.agent.md` also
+ * accepted) and converts them into JudgeDefinition objects that register with
+ * the unified JudgeRegistry.
+ *
+ * This is the bridge between the file-based agent paradigm and the existing
+ * TypeScript judge system. Agent files use YAML frontmatter for metadata
+ * and markdown body for the system prompt (persona + evaluation criteria).
+ *
+ * ## File Format
+ *
+ * ```markdown
+ * ---
+ * id: cybersecurity
+ * name: Judge Cybersecurity
+ * domain: Cybersecurity & Threat Defense
+ * rulePrefix: CYBER
+ * description: Evaluates code for vulnerability...
+ * tableDescription: "Injection attacks, XSS, CSRF, auth flaws"
+ * promptDescription: Deep cybersecurity review
+ * script: ../src/evaluators/cybersecurity.ts   # optional
+ * priority: 10                                  # optional, default 10
+ * ---
+ *
+ * You are Judge Cybersecurity — a principal application security engineer...
+ *
+ * ## Evaluation Criteria
+ * ...
+ * ```
+ *
+ * - `script` is a relative path to the evaluator module (must export a
+ *   function matching `(code: string, language: string, context?) => Finding[]`).
+ *   If omitted, the judge is LLM-only (no deterministic layer).
+ * - `priority` controls ordering. Higher = later. 999 is reserved for
+ *   false-positive-review (always last). Default is 10.
+ */
+import type { JudgeDefinition, Finding, AnalyzeContext } from "./types.js";
+/** Parsed YAML frontmatter from a `.judge.md` file (legacy `.agent.md`). */
+export interface AgentFrontmatter {
+    id: string;
+    name: string;
+    domain: string;
+    rulePrefix: string;
+    description: string;
+    tableDescription: string;
+    promptDescription: string;
+    script?: string;
+    priority?: number;
+}
+/** A parsed agent file — metadata + the markdown body (system prompt). */
+export interface ParsedAgent {
+    frontmatter: AgentFrontmatter;
+    /** The markdown body below the frontmatter — becomes the systemPrompt. */
+    body: string;
+    /** Absolute path of the source `.judge.md` file (legacy `.agent.md`). */
+    sourcePath: string;
+}
+/**
+ * Parse YAML frontmatter from a string. Handles the subset of YAML used
+ * by agent files: simple key-value pairs, quoted strings, and multi-line
+ * `>` folded scalars. No arrays, nested objects, or anchors.
+ */
+export declare function parseFrontmatter(raw: string): {
+    meta: Record<string, string>;
+    body: string;
+};
+/**
+ * Validate and coerce parsed frontmatter into a typed AgentFrontmatter.
+ * Throws on missing required fields.
+ */
+export declare function validateFrontmatter(meta: Record<string, string>, sourcePath: string): AgentFrontmatter;
+/**
+ * Parse a single `.judge.md` file into its frontmatter and body (legacy `.agent.md`).
+ */
+export declare function parseAgentFile(filePath: string): ParsedAgent;
+/**
+ * Resolve the `script` path to an analyze function.
+ *
+ * Requirements:
+ * - Synchronous (to support existing synchronous evaluation paths)
+ * - Works both from source (`tsx`/ts-node) and compiled `dist`
+ */
+type AnalyzeFn = (code: string, language: string, context?: AnalyzeContext) => Finding[];
+export declare function resolveEvaluator(agent: ParsedAgent): AnalyzeFn | undefined;
+/**
+ * Convert a parsed agent file to a JudgeDefinition, reconstructing the
+ * systemPrompt from the markdown body with the standard adversarial
+ * mandate appended.
+ */
+export declare function agentToJudgeDefinition(agent: ParsedAgent, analyze?: (code: string, language: string, context?: AnalyzeContext) => Finding[]): JudgeDefinition;
+/**
+ * Load all `.judge.md` files from a directory (legacy `.agent.md` supported)
+ * and return parsed agents sorted by priority (ascending — lower number =
+ * earlier in pipeline).
+ */
+export declare function loadAgentDirectory(dirPath: string): ParsedAgent[];
+/**
+ * Load all agent files from a directory and register them with the
+ * JudgeRegistry. This is the main entry point for the hybrid phase.
+ *
+ * Returns the number of agents loaded.
+ */
+export declare function loadAndRegisterAgents(dirPath: string, registry: {
+    register: (judge: JudgeDefinition) => void;
+    getJudge: (id: string) => JudgeDefinition | undefined;
+}): number;
+export {};

package/dist/agent-loader.js

@@ -0,0 +1,254 @@
+/**
+ * Agent Markdown Loader — reads `.judge.md` files (legacy `.agent.md` also
+ * accepted) and converts them into JudgeDefinition objects that register with
+ * the unified JudgeRegistry.
+ *
+ * This is the bridge between the file-based agent paradigm and the existing
+ * TypeScript judge system. Agent files use YAML frontmatter for metadata
+ * and markdown body for the system prompt (persona + evaluation criteria).
+ *
+ * ## File Format
+ *
+ * ```markdown
+ * ---
+ * id: cybersecurity
+ * name: Judge Cybersecurity
+ * domain: Cybersecurity & Threat Defense
+ * rulePrefix: CYBER
+ * description: Evaluates code for vulnerability...
+ * tableDescription: "Injection attacks, XSS, CSRF, auth flaws"
+ * promptDescription: Deep cybersecurity review
+ * script: ../src/evaluators/cybersecurity.ts   # optional
+ * priority: 10                                  # optional, default 10
+ * ---
+ *
+ * You are Judge Cybersecurity — a principal application security engineer...
+ *
+ * ## Evaluation Criteria
+ * ...
+ * ```
+ *
+ * - `script` is a relative path to the evaluator module (must export a
+ *   function matching `(code: string, language: string, context?) => Finding[]`).
+ *   If omitted, the judge is LLM-only (no deterministic layer).
+ * - `priority` controls ordering. Higher = later. 999 is reserved for
+ *   false-positive-review (always last). Default is 10.
+ */
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { createRequire } from "node:module";
+// ─── Frontmatter Parser ─────────────────────────────────────────────────────
+/**
+ * Parse YAML frontmatter from a string. Handles the subset of YAML used
+ * by agent files: simple key-value pairs, quoted strings, and multi-line
+ * `>` folded scalars. No arrays, nested objects, or anchors.
+ */
+export function parseFrontmatter(raw) {
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+    if (!match) {
+        return { meta: {}, body: raw };
+    }
+    const yamlBlock = match[1];
+    const body = match[2].trim();
+    const meta = {};
+    const lines = yamlBlock.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        // Skip empty lines and comments
+        if (!line.trim() || line.trim().startsWith("#")) {
+            i++;
+            continue;
+        }
+        const kvMatch = line.match(/^([a-zA-Z_][a-zA-Z0-9_]*)\s*:\s*(.*)/);
+        if (!kvMatch) {
+            i++;
+            continue;
+        }
+        const key = kvMatch[1];
+        let value = kvMatch[2].trim();
+        // Handle folded scalar (>)
+        if (value === ">") {
+            const parts = [];
+            i++;
+            while (i < lines.length && (lines[i].startsWith("  ") || lines[i].trim() === "")) {
+                if (lines[i].trim() === "") {
+                    parts.push("");
+                }
+                else {
+                    parts.push(lines[i].trimStart());
+                }
+                i++;
+            }
+            // Folded scalar: join non-empty lines with spaces, blank lines become newlines
+            value = parts
+                .reduce((acc, part) => {
+                if (part === "") {
+                    acc.push("\n");
+                }
+                else if (acc.length > 0 && acc[acc.length - 1] !== "\n") {
+                    acc[acc.length - 1] += " " + part;
+                }
+                else {
+                    acc.push(part);
+                }
+                return acc;
+            }, [])
+                .join("")
+                .trim();
+        }
+        else {
+            // Strip surrounding quotes
+            if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+                value = value.slice(1, -1);
+            }
+            i++;
+        }
+        meta[key] = value;
+    }
+    return { meta, body };
+}
+// ─── Validation ──────────────────────────────────────────────────────────────
+const REQUIRED_FIELDS = [
+    "id",
+    "name",
+    "domain",
+    "rulePrefix",
+    "description",
+    "tableDescription",
+    "promptDescription",
+];
+/**
+ * Validate and coerce parsed frontmatter into a typed AgentFrontmatter.
+ * Throws on missing required fields.
+ */
+export function validateFrontmatter(meta, sourcePath) {
+    for (const field of REQUIRED_FIELDS) {
+        if (!meta[field]) {
+            throw new Error(`Agent file ${sourcePath} is missing required field: "${field}"`);
+        }
+    }
+    return {
+        id: meta.id,
+        name: meta.name,
+        domain: meta.domain,
+        rulePrefix: meta.rulePrefix,
+        description: meta.description,
+        tableDescription: meta.tableDescription,
+        promptDescription: meta.promptDescription,
+        script: meta.script || undefined,
+        priority: meta.priority ? parseInt(meta.priority, 10) : 10,
+    };
+}
+// ─── Agent File Parsing ──────────────────────────────────────────────────────
+/**
+ * Parse a single `.judge.md` file into its frontmatter and body (legacy `.agent.md`).
+ */
+export function parseAgentFile(filePath) {
+    const absPath = resolve(filePath);
+    const raw = readFileSync(absPath, "utf-8");
+    const { meta, body } = parseFrontmatter(raw);
+    const frontmatter = validateFrontmatter(meta, absPath);
+    return {
+        frontmatter,
+        body,
+        sourcePath: absPath,
+    };
+}
+export function resolveEvaluator(agent) {
+    if (!agent.frontmatter.script)
+        return undefined;
+    const scriptPath = resolve(dirname(agent.sourcePath), agent.frontmatter.script);
+    const candidatePaths = [
+        scriptPath,
+        scriptPath.replace(/\.ts$/, ".js"),
+        scriptPath
+            .replace(/\\src\\/g, "\\dist\\")
+            .replace(/\/src\//g, "/dist/")
+            .replace(/\.ts$/, ".js"),
+        resolve(process.cwd(), "dist", "evaluators", `${agent.frontmatter.id}.js`),
+    ];
+    const req = createRequire(import.meta.url);
+    for (const candidate of candidatePaths) {
+        try {
+            const mod = req(candidate);
+            const pascalId = agent.frontmatter.id
+                .split("-")
+                .map((s) => s.charAt(0).toUpperCase() + s.slice(1))
+                .join("");
+            const fnName = `analyze${pascalId}`;
+            const maybeFn = mod?.[fnName];
+            if (typeof maybeFn === "function")
+                return maybeFn;
+            for (const key of Object.keys(mod || {})) {
+                const candidateFn = mod[key];
+                if (typeof candidateFn === "function" && key.startsWith("analyze"))
+                    return candidateFn;
+            }
+        }
+        catch {
+            // swallow and try next
+        }
+    }
+    return undefined;
+}
+// ─── Conversion to JudgeDefinition ───────────────────────────────────────────
+/**
+ * Convert a parsed agent file to a JudgeDefinition, reconstructing the
+ * systemPrompt from the markdown body with the standard adversarial
+ * mandate appended.
+ */
+export function agentToJudgeDefinition(agent, analyze) {
+    const fm = agent.frontmatter;
+    // The markdown body IS the system prompt content. We prepend the persona
+    // line (which is typically the first line of the body) and leave the
+    // rest as structured evaluation criteria.
+    const systemPrompt = agent.body;
+    return {
+        id: fm.id,
+        name: fm.name,
+        domain: fm.domain,
+        description: fm.description,
+        rulePrefix: fm.rulePrefix,
+        tableDescription: fm.tableDescription,
+        promptDescription: fm.promptDescription,
+        systemPrompt,
+        ...(analyze ? { analyze } : {}),
+    };
+}
+// ─── Directory Loading ───────────────────────────────────────────────────────
+/**
+ * Load all `.judge.md` files from a directory (legacy `.agent.md` supported)
+ * and return parsed agents sorted by priority (ascending — lower number =
+ * earlier in pipeline).
+ */
+export function loadAgentDirectory(dirPath) {
+    const absDir = resolve(dirPath);
+    if (!existsSync(absDir))
+        return [];
+    const files = readdirSync(absDir).filter((f) => /\.(agent|judge)\.md$/i.test(f));
+    return files
+        .map((f) => parseAgentFile(join(absDir, f)))
+        .sort((a, b) => (a.frontmatter.priority ?? 10) - (b.frontmatter.priority ?? 10));
+}
+/**
+ * Load all agent files from a directory and register them with the
+ * JudgeRegistry. This is the main entry point for the hybrid phase.
+ *
+ * Returns the number of agents loaded.
+ */
+export function loadAndRegisterAgents(dirPath, registry) {
+    const agents = loadAgentDirectory(dirPath);
+    let count = 0;
+    for (const agent of agents) {
+        // Skip if a judge with this ID already exists (built-ins or previously loaded agents)
+        if (registry.getJudge(agent.frontmatter.id)) {
+            continue;
+        }
+        const analyze = resolveEvaluator(agent);
+        const judge = agentToJudgeDefinition(agent, analyze);
+        registry.register(judge);
+        count++;
+    }
+    return count;
+}

package/dist/context/context-snippets.d.ts

@@ -0,0 +1,15 @@
+import { EmbeddingCache } from "./embedding-cache.js";
+export interface ContextOptions {
+    chunkSize?: number;
+    overlap?: number;
+    maxSnippets?: number;
+    embeddingCache?: EmbeddingCache;
+    embeddingSalt?: string;
+}
+/**
+ * Naive chunker for code/docs. Returns plain text chunks; embeddings computed for ranking.
+ */
+export declare function buildContextSnippets(text: string, opts?: ContextOptions): Promise<Array<{
+    snippet: string;
+    score: number;
+}>>;

package/dist/context/context-snippets.js

@@ -0,0 +1,36 @@
+import { getOrCreateEmbedding, EmbeddingCache, FallbackEmbeddingProvider } from "./embedding-cache.js";
+const DEFAULT_CHUNK_SIZE = 1200; // chars (~300 tokens)
+const DEFAULT_OVERLAP = 200;
+const DEFAULT_MAX_SNIPPETS = 5;
+/**
+ * Naive chunker for code/docs. Returns plain text chunks; embeddings computed for ranking.
+ */
+export async function buildContextSnippets(text, opts = {}) {
+    const chunkSize = opts.chunkSize ?? DEFAULT_CHUNK_SIZE;
+    const overlap = opts.overlap ?? DEFAULT_OVERLAP;
+    const maxSnippets = opts.maxSnippets ?? DEFAULT_MAX_SNIPPETS;
+    const cache = opts.embeddingCache ?? new EmbeddingCache();
+    const provider = new FallbackEmbeddingProvider();
+    const chunks = [];
+    for (let i = 0; i < text.length; i += chunkSize - overlap) {
+        chunks.push(text.slice(i, i + chunkSize));
+    }
+    // Compute simple scores using fallback embeddings (dot product with a centroid)
+    const centroid = await getOrCreateEmbedding(cache, provider, text, opts.embeddingSalt);
+    const centroidVec = centroid.embedding;
+    const scored = [];
+    for (const c of chunks) {
+        const chunkEmbedding = await getOrCreateEmbedding(cache, provider, c, opts.embeddingSalt);
+        const score = dot(centroidVec, chunkEmbedding.embedding);
+        scored.push({ snippet: c, score });
+    }
+    scored.sort((a, b) => b.score - a.score);
+    return scored.slice(0, maxSnippets);
+}
+function dot(a, b) {
+    const len = Math.min(a.length, b.length);
+    let sum = 0;
+    for (let i = 0; i < len; i++)
+        sum += a[i] * b[i];
+    return sum;
+}

package/dist/context/embedding-cache.d.ts

@@ -0,0 +1,30 @@
+export interface EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+}
+export interface EmbeddingChunk {
+    hash: string;
+    embedding: number[];
+    text: string;
+    metadata?: Record<string, unknown>;
+}
+/** Simple SHA1 hash for cache keys (content + salt/context). */
+export declare function hashKey(text: string, salt?: string): string;
+/**
+ * In-memory embedding cache (can be backed by disk later). Lightweight and
+ * dependency-free; callers can persist via JSON if desired.
+ */
+export declare class EmbeddingCache {
+    private cache;
+    get(key: string): EmbeddingChunk | undefined;
+    set(key: string, value: EmbeddingChunk): void;
+    clear(): void;
+}
+/**
+ * Trivial embedding provider (fallback) — returns normalized character code vector.
+ * Not semantically meaningful but keeps the pipeline working when no provider is configured.
+ */
+export declare class FallbackEmbeddingProvider implements EmbeddingProvider {
+    embed(text: string): Promise<number[]>;
+}
+/** Retrieve or compute an embedding, with caching. */
+export declare function getOrCreateEmbedding(cache: EmbeddingCache, provider: EmbeddingProvider, text: string, salt?: string): Promise<EmbeddingChunk>;

package/dist/context/embedding-cache.js

@@ -0,0 +1,48 @@
+import { createHash } from "node:crypto";
+/** Simple SHA1 hash for cache keys (content + salt/context). */
+export function hashKey(text, salt) {
+    return createHash("sha1")
+        .update(text + (salt ?? ""))
+        .digest("hex");
+}
+/**
+ * In-memory embedding cache (can be backed by disk later). Lightweight and
+ * dependency-free; callers can persist via JSON if desired.
+ */
+export class EmbeddingCache {
+    cache = new Map();
+    get(key) {
+        return this.cache.get(key);
+    }
+    set(key, value) {
+        this.cache.set(key, value);
+    }
+    clear() {
+        this.cache.clear();
+    }
+}
+/**
+ * Trivial embedding provider (fallback) — returns normalized character code vector.
+ * Not semantically meaningful but keeps the pipeline working when no provider is configured.
+ */
+export class FallbackEmbeddingProvider {
+    async embed(text) {
+        const vec = new Array(32).fill(0);
+        for (let i = 0; i < text.length; i++) {
+            vec[i % vec.length] += text.charCodeAt(i);
+        }
+        const norm = Math.sqrt(vec.reduce((s, v) => s + v * v, 0)) || 1;
+        return vec.map((v) => v / norm);
+    }
+}
+/** Retrieve or compute an embedding, with caching. */
+export async function getOrCreateEmbedding(cache, provider, text, salt) {
+    const key = hashKey(text, salt);
+    const cached = cache.get(key);
+    if (cached)
+        return cached;
+    const embedding = await provider.embed(text);
+    const chunk = { hash: key, embedding, text };
+    cache.set(key, chunk);
+    return chunk;
+}

package/dist/skill-loader.d.ts

@@ -0,0 +1,33 @@
+import type { TribunalVerdict } from "./types.js";
+export interface SkillFrontmatter {
+    id: string;
+    name: string;
+    description: string;
+    agents: string[];
+    tags?: string[];
+    priority?: number;
+}
+export interface ParsedSkill {
+    frontmatter: SkillFrontmatter;
+    body: string;
+    sourcePath: string;
+}
+type SkillMeta = Record<string, unknown>;
+export declare function parseSkillFrontmatter(raw: string): {
+    meta: SkillMeta;
+    body: string;
+};
+export declare function validateSkillFrontmatter(meta: SkillMeta, sourcePath: string): SkillFrontmatter;
+export declare function parseSkillFile(filePath: string): ParsedSkill;
+export declare function loadSkillDirectory(dirPath: string): ParsedSkill[];
+/** List skills with metadata for display (id, name, description). */
+export declare function listSkills(dirPath: string): Array<Pick<SkillFrontmatter, "id" | "name" | "description" | "tags" | "agents">>;
+/**
+ * Run a skill by ID. Loads any missing agent judges, then evaluates code using
+ * only the judges referenced by the skill. Returns a tribunal verdict.
+ */
+export declare function runSkill(skillId: string, code: string, language: string, opts?: {
+    skillsDir?: string;
+    context?: unknown;
+}): Promise<TribunalVerdict>;
+export {};

package/dist/skill-loader.js

@@ -0,0 +1,162 @@
+/**
+ * Skill Loader — reads `.skill.md` files and converts them into skill
+ * definitions that orchestrate sets of judges/agents. A skill represents a
+ * reusable review workflow (e.g., AI code review, security gate, release gate).
+ */
+import { readFileSync, readdirSync, existsSync } from "node:fs";
+import { join, resolve, dirname } from "node:path";
+import { fileURLToPath } from "node:url";
+import { evaluateWithTribunal } from "./evaluators/index.js";
+import { defaultRegistry } from "./judge-registry.js";
+import { loadAgentJudges } from "./judges/index.js";
+export function parseSkillFrontmatter(raw) {
+    const match = raw.match(/^---\r?\n([\s\S]*?)\r?\n---\r?\n([\s\S]*)$/);
+    if (!match) {
+        return { meta: {}, body: raw };
+    }
+    const yamlBlock = match[1];
+    const body = match[2].trim();
+    const meta = {};
+    const lines = yamlBlock.split(/\r?\n/);
+    let i = 0;
+    while (i < lines.length) {
+        const line = lines[i];
+        if (!line.trim() || line.trim().startsWith("#")) {
+            i++;
+            continue;
+        }
+        const kv = line.match(/^([a-zA-Z_][a-zA-Z0-9_-]*)\s*:\s*(.*)$/);
+        if (!kv) {
+            i++;
+            continue;
+        }
+        const key = kv[1];
+        let value = kv[2].trim();
+        // Multi-line array (YAML list)
+        if (!value || value === "|") {
+            // Peek ahead for indented or dash-prefixed lines
+            const items = [];
+            i++;
+            while (i < lines.length) {
+                const next = lines[i];
+                if (!next.trim()) {
+                    i++;
+                    continue;
+                }
+                if (/^\s*-\s+/.test(next)) {
+                    items.push(next.replace(/^\s*-\s+/, "").trim());
+                    i++;
+                    continue;
+                }
+                if (/^\s{2,}\S/.test(next)) {
+                    items.push(next.trim());
+                    i++;
+                    continue;
+                }
+                break; // end of list
+            }
+            if (items.length > 0) {
+                meta[key] = items;
+                continue;
+            }
+            // fall through if no items captured
+        }
+        if (typeof value === "string" && ((value.startsWith("[") && value.endsWith("]")) || value.includes(","))) {
+            // simple array parsing: split on comma
+            const normalized = value
+                .replace(/^\s*\[/, "")
+                .replace(/\]\s*$/, "")
+                .split(/\s*,\s*/)
+                .filter(Boolean);
+            value = normalized;
+        }
+        else if (typeof value === "string" &&
+            ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'")))) {
+            value = value.slice(1, -1);
+        }
+        meta[key] = value;
+        i++;
+    }
+    return { meta, body };
+}
+const REQUIRED_FIELDS = ["id", "name", "description", "agents"];
+export function validateSkillFrontmatter(meta, sourcePath) {
+    for (const field of REQUIRED_FIELDS) {
+        if (!meta[field] || (Array.isArray(meta[field]) && meta[field].length === 0)) {
+            throw new Error(`Skill file ${sourcePath} is missing required field: "${field}"`);
+        }
+    }
+    return {
+        id: String(meta.id),
+        name: String(meta.name),
+        description: String(meta.description),
+        agents: Array.isArray(meta.agents)
+            ? meta.agents
+            : String(meta.agents ?? "")
+                .split(/\s*,\s*/)
+                .filter(Boolean),
+        tags: Array.isArray(meta.tags)
+            ? meta.tags
+            : meta.tags
+                ? String(meta.tags)
+                    .split(/\s*,\s*/)
+                    .filter(Boolean)
+                : undefined,
+        priority: meta.priority ? Number(meta.priority) : 10,
+    };
+}
+export function parseSkillFile(filePath) {
+    const absPath = resolve(filePath);
+    const raw = readFileSync(absPath, "utf-8");
+    const { meta, body } = parseSkillFrontmatter(raw);
+    const frontmatter = validateSkillFrontmatter(meta, absPath);
+    return { frontmatter, body, sourcePath: absPath };
+}
+export function loadSkillDirectory(dirPath) {
+    const absDir = resolve(dirPath);
+    if (!existsSync(absDir))
+        return [];
+    return readdirSync(absDir)
+        .filter((f) => f.endsWith(".skill.md"))
+        .map((f) => parseSkillFile(join(absDir, f)))
+        .sort((a, b) => (a.frontmatter.priority ?? 10) - (b.frontmatter.priority ?? 10));
+}
+/** List skills with metadata for display (id, name, description). */
+export function listSkills(dirPath) {
+    return loadSkillDirectory(dirPath).map((s) => ({
+        id: s.frontmatter.id,
+        name: s.frontmatter.name,
+        description: s.frontmatter.description,
+        tags: s.frontmatter.tags,
+        agents: s.frontmatter.agents,
+    }));
+}
+/**
+ * Run a skill by ID. Loads any missing agent judges, then evaluates code using
+ * only the judges referenced by the skill. Returns a tribunal verdict.
+ */
+export async function runSkill(skillId, code, language, opts) {
+    const skillsDir = opts?.skillsDir ?? resolve(dirname(fileURLToPath(import.meta.url)), "..", "skills");
+    const skills = loadSkillDirectory(skillsDir);
+    const skill = skills.find((s) => s.frontmatter.id === skillId);
+    if (!skill)
+        throw new Error(`Skill not found: ${skillId}`);
+    // Load agent judges referenced by the skill
+    loadAgentJudges();
+    const judges = [];
+    for (const id of skill.frontmatter.agents) {
+        const judge = defaultRegistry.getJudge(id);
+        if (!judge) {
+            throw new Error(`Judge referenced by skill not found in registry: ${id}`);
+        }
+        judges.push(judge);
+    }
+    const allJudgeIds = defaultRegistry.getJudges().map((j) => j.id);
+    const enabled = new Set(skill.frontmatter.agents);
+    const disabled = allJudgeIds.filter((id) => !enabled.has(id));
+    return evaluateWithTribunal(code, language, `skill:${skill.frontmatter.id}`, {
+        config: {
+            disabledJudges: disabled,
+        },
+    });
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kevinrabun/judges",
-  "version": "3.115.0",
+  "version": "3.115.1",
   "description": "45 specialized judges that evaluate AI-generated code for security, cost, and quality.",
   "mcpName": "io.github.KevinRabun/judges",
   "type": "module",
@@ -89,6 +89,12 @@
     "scripts/generate-skills-docs.ts",
     "src/agent-loader.ts",
     "src/skill-loader.ts",
+    "dist/agent-loader.js",
+    "dist/agent-loader.d.ts",
+    "dist/skill-loader.js",
+    "dist/skill-loader.d.ts",
+    "dist/context/**/*.js",
+    "dist/context/**/*.d.ts",
     "dist/github-app.js",
     "dist/github-app.d.ts",
     "dist/index.js",

package/server.json

@@ -7,12 +7,12 @@
     "url": "https://github.com/kevinrabun/judges",
     "source": "github"
   },
-  "version": "3.115.0",
+  "version": "3.115.1",
   "packages": [
     {
       "registryType": "npm",
       "identifier": "@kevinrabun/judges",
-      "version": "3.115.0",
+      "version": "3.115.1",
       "transport": {
         "type": "stdio"
       }