agent-skill-manager 1.20.0 → 1.22.0

package/node_modules/skillgrade/dist/commands/run.js

@@ -0,0 +1,302 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runEvals = runEvals;
+/**
+ * `skillgrade` (run) command.
+ *
+ * Reads eval.yaml, resolves tasks, and executes evals.
+ */
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const config_1 = require("../core/config");
+const skills_1 = require("../core/skills");
+const docker_1 = require("../providers/docker");
+const local_1 = require("../providers/local");
+const evalRunner_1 = require("../evalRunner");
+const registry_1 = require("../agents/registry");
+const env_1 = require("../utils/env");
+const cli_1 = require("../utils/cli");
+async function loadEnvFile(filePath) {
+    if (await fs.pathExists(filePath)) {
+        return (0, env_1.parseEnvFile)(await fs.readFile(filePath, 'utf-8'));
+    }
+    return {};
+}
+async function runEvals(dir, opts) {
+    console.log(`\n${cli_1.fmt.bold('skillgrade')}\n`);
+    // Load eval.yaml
+    const config = await (0, config_1.loadEvalConfig)(dir);
+    // Load environment variables
+    const rootEnv = await loadEnvFile(path.join(dir, '.env'));
+    const env = { ...rootEnv };
+    if (process.env.GEMINI_API_KEY)
+        env.GEMINI_API_KEY = process.env.GEMINI_API_KEY;
+    if (process.env.ANTHROPIC_API_KEY)
+        env.ANTHROPIC_API_KEY = process.env.ANTHROPIC_API_KEY;
+    if (process.env.OPENAI_API_KEY)
+        env.OPENAI_API_KEY = process.env.OPENAI_API_KEY;
+    if (Object.keys(rootEnv).length > 0) {
+        (0, cli_1.kv)('env', Object.keys(rootEnv).join(', '));
+    }
+    // Detect skills
+    let skillsPaths = [];
+    if (config.skill) {
+        let skillDir = path.resolve(dir, config.skill);
+        const stat = await fs.stat(skillDir).catch(() => null);
+        if (stat?.isFile()) {
+            skillDir = path.dirname(skillDir);
+        }
+        if (stat && await fs.pathExists(skillDir)) {
+            skillsPaths = [skillDir];
+            (0, cli_1.kv)('skill', path.relative(dir, skillDir) || '.');
+        }
+        else {
+            console.error(`  ${cli_1.fmt.red('warning')}  skill path not found: ${config.skill}`);
+        }
+    }
+    else {
+        const skills = await (0, skills_1.detectSkills)(dir);
+        skillsPaths = skills.map(s => s.path);
+        if (skills.length > 0) {
+            (0, cli_1.kv)('skills', skills.map(s => s.name).join(', '));
+        }
+    }
+    // Filter evals
+    let tasksToRun = config.tasks;
+    if (opts.eval) {
+        const evalNames = opts.eval.split(',').map(s => s.trim());
+        tasksToRun = config.tasks.filter(t => evalNames.includes(t.name));
+        if (tasksToRun.length === 0) {
+            console.error(`  ${cli_1.fmt.red('error')}  eval "${opts.eval}" not found`);
+            console.log(`  ${cli_1.fmt.dim('available:')} ${config.tasks.map(t => t.name).join(', ')}`);
+            throw new Error(`Eval "${opts.eval}" not found`);
+        }
+    }
+    // Output directory
+    const outputBase = opts.output || path.join(os.tmpdir(), 'skillgrade');
+    const skillName = path.basename(dir);
+    const outputDir = path.join(outputBase, skillName);
+    const resultsDir = path.join(outputDir, 'results');
+    await fs.ensureDir(resultsDir);
+    (0, cli_1.kv)('output', outputDir);
+    // Track CI results
+    const reports = [];
+    let allPassed = true;
+    // Run each task
+    for (const taskDef of tasksToRun) {
+        const resolved = await (0, config_1.resolveTask)(taskDef, config.defaults, dir);
+        const trials = opts.trials ?? resolved.trials;
+        const parallel = opts.parallel ?? 1;
+        // Create a temp task directory for Docker builds
+        const tmpTaskDir = path.join(outputDir, 'tmp', resolved.name);
+        await prepareTempTaskDir(resolved, dir, tmpTaskDir);
+        // Build eval options — pass resolved content directly
+        const evalOpts = {
+            instruction: resolved.instruction,
+            graders: opts.grader
+                ? resolved.graders.filter(g => g.type === opts.grader)
+                : resolved.graders,
+            timeoutSec: resolved.timeout,
+            graderModel: resolved.grader_model,
+            environment: resolved.environment,
+        };
+        // Pick agent: CLI flag > task-level override > auto-detect from API key > default
+        let agentName = opts.agent || resolved.agent;
+        if (!opts.agent && !taskDef.agent) {
+            // No explicit override — auto-detect from available API keys
+            const hasGemini = !!env.GEMINI_API_KEY;
+            const hasAnthropic = !!env.ANTHROPIC_API_KEY;
+            const hasOpenAI = !!env.OPENAI_API_KEY;
+            const keyCount = [hasGemini, hasAnthropic, hasOpenAI].filter(Boolean).length;
+            if (keyCount === 1) {
+                if (hasAnthropic)
+                    agentName = 'claude';
+                else if (hasOpenAI)
+                    agentName = 'codex';
+                else if (hasGemini)
+                    agentName = 'gemini';
+            }
+        }
+        const providerName = opts.provider || resolved.provider;
+        // Pick provider
+        const provider = providerName === 'docker'
+            ? new docker_1.DockerProvider()
+            : new local_1.LocalProvider();
+        const runner = new evalRunner_1.EvalRunner(provider, resultsDir);
+        if (opts.validate) {
+            // Validation mode
+            if (!resolved.solution) {
+                console.error(`  ${cli_1.fmt.red('error')}  task "${resolved.name}" has no solution defined`);
+                continue;
+            }
+            (0, cli_1.header)(`validate: ${resolved.name}`);
+            const solveAgent = {
+                async run(_instruction, _workspace, runCommand) {
+                    const result = await runCommand(`bash ${path.basename(resolved.solution)}`);
+                    return result.stdout;
+                }
+            };
+            const report = await runner.runEval(solveAgent, tmpTaskDir, skillsPaths, evalOpts, 1, env);
+            const passed = report.trials[0].reward >= 0.5;
+            (0, cli_1.validationResult)(passed, report.trials[0].reward, report.trials[0].grader_results.map(gr => ({
+                type: gr.grader_type,
+                score: gr.score,
+                details: gr.details
+            })));
+            if (!passed)
+                allPassed = false;
+        }
+        else {
+            // Normal eval mode
+            const agent = (0, registry_1.createAgent)(agentName);
+            (0, cli_1.header)(resolved.name);
+            console.log(`    ${cli_1.fmt.dim('agent')} ${agentName}  ${cli_1.fmt.dim('provider')} ${providerName}  ${cli_1.fmt.dim('trials')} ${trials}${parallel > 1 ? `  ${cli_1.fmt.dim('parallel')} ${parallel}` : ''}`);
+            console.log();
+            try {
+                const report = await runner.runEval(agent, tmpTaskDir, skillsPaths, evalOpts, trials, env, parallel);
+                reports.push(report);
+                // LLM grader reasoning (condensed)
+                for (const trial of report.trials) {
+                    for (const g of trial.grader_results.filter(g => g.grader_type === 'llm_rubric')) {
+                        console.log(`    ${cli_1.fmt.dim(`trial ${trial.trial_id} llm_rubric:`)} ${g.details.substring(0, 120)}`);
+                    }
+                }
+                (0, cli_1.resultsSummary)(report.pass_rate, report.pass_at_k, report.pass_pow_k, trials, opts.preset);
+                if (report.pass_rate < (opts.threshold ?? config.defaults.threshold)) {
+                    allPassed = false;
+                }
+            }
+            catch (err) {
+                console.error(`\n  ${cli_1.fmt.fail('error')}  evaluation failed: ${err}\n`);
+                allPassed = false;
+            }
+        }
+        // Cleanup temp dir
+        try {
+            await fs.remove(tmpTaskDir);
+        }
+        catch { /* ignore cleanup errors */ }
+    }
+    // CI mode: exit with appropriate code
+    if (opts.ci) {
+        const threshold = opts.threshold ?? config.defaults.threshold;
+        if (!allPassed) {
+            console.error(`\n  ${cli_1.fmt.fail('CI FAILED')}  below threshold ${(threshold * 100).toFixed(0)}%\n`);
+            throw new Error('CI check failed');
+        }
+        console.log(`\n  ${cli_1.fmt.pass('CI PASSED')}  above threshold ${(threshold * 100).toFixed(0)}%\n`);
+    }
+}
+/**
+ * Create a temp task directory for Docker builds.
+ * Contains: Dockerfile, workspace files, grader scripts.
+ * No longer writes task.toml or instruction.md — those are passed directly.
+ */
+async function prepareTempTaskDir(resolved, baseDir, tmpDir) {
+    await fs.ensureDir(tmpDir);
+    // Write each deterministic grader script
+    await fs.ensureDir(path.join(tmpDir, 'tests'));
+    const detGraders = resolved.graders.filter(g => g.type === 'deterministic');
+    for (let i = 0; i < detGraders.length; i++) {
+        if (detGraders[i].run) {
+            const script = `#!/bin/bash\n${detGraders[i].run.trim()}\n`;
+            const filename = i === 0 ? 'test.sh' : `test_${i}.sh`;
+            await fs.writeFile(path.join(tmpDir, 'tests', filename), script);
+        }
+    }
+    // Copy referenced grader files/directories
+    for (const g of resolved.graders) {
+        if (g.type === 'deterministic' && g.run) {
+            const pathMatches = g.run.match(/[\w./-]+\.\w{1,4}/g) || [];
+            for (const ref of pathMatches) {
+                const refDir = ref.split('/')[0];
+                const srcDir = path.resolve(baseDir, refDir);
+                const destDir = path.join(tmpDir, refDir);
+                if (refDir !== ref && await fs.pathExists(srcDir) && !await fs.pathExists(destDir)) {
+                    await fs.copy(srcDir, destDir);
+                }
+            }
+        }
+    }
+    // Write each LLM rubric
+    await fs.ensureDir(path.join(tmpDir, 'prompts'));
+    const llmGraders = resolved.graders.filter(g => g.type === 'llm_rubric');
+    for (let i = 0; i < llmGraders.length; i++) {
+        if (llmGraders[i].rubric) {
+            const filename = i === 0 ? 'quality.md' : `quality_${i}.md`;
+            await fs.writeFile(path.join(tmpDir, 'prompts', filename), llmGraders[i].rubric);
+        }
+    }
+    // Write Dockerfile
+    await fs.ensureDir(path.join(tmpDir, 'environment'));
+    let dockerfileContent = `FROM ${resolved.docker.base}\n\nWORKDIR /workspace\n\n`;
+    // Install agent CLI
+    if (resolved.agent === 'gemini') {
+        dockerfileContent += `RUN npm install -g @google/gemini-cli\n\n`;
+    }
+    else if (resolved.agent === 'claude') {
+        dockerfileContent += `RUN npm install -g @anthropic-ai/claude-code\n\n`;
+    }
+    else if (resolved.agent === 'codex') {
+        dockerfileContent += `RUN npm install -g @openai/codex\n\n`;
+    }
+    // Docker setup commands
+    if (resolved.docker.setup) {
+        dockerfileContent += `RUN ${resolved.docker.setup.trim()}\n\n`;
+    }
+    // Grader setup commands
+    for (const g of resolved.graders) {
+        if (g.setup) {
+            dockerfileContent += `# Grader setup\nRUN ${g.setup.trim()}\n\n`;
+        }
+    }
+    // Copy workspace files
+    for (const w of resolved.workspace) {
+        const srcPath = path.resolve(baseDir, w.src);
+        const destInTmp = path.join(tmpDir, path.basename(w.src));
+        if (await fs.pathExists(srcPath)) {
+            await fs.copy(srcPath, destInTmp);
+            dockerfileContent += `COPY ${path.basename(w.src)} ${w.dest}\n`;
+            if (w.chmod) {
+                dockerfileContent += `RUN chmod ${w.chmod} ${w.dest}\n`;
+            }
+        }
+    }
+    dockerfileContent += `\nCOPY . .\nCMD ["bash"]\n`;
+    await fs.writeFile(path.join(tmpDir, 'environment', 'Dockerfile'), dockerfileContent);
+}
+//# sourceMappingURL=run.js.map

package/node_modules/skillgrade/dist/core/config.d.ts

@@ -0,0 +1,10 @@
+import { EvalConfig, EvalDefaults, EvalTaskConfig, ResolvedTask } from './config.types';
+/**
+ * Load and parse eval.yaml from a directory.
+ */
+export declare function loadEvalConfig(dir: string): Promise<EvalConfig>;
+/**
+ * Resolve a single task: apply defaults, resolve file references to content.
+ */
+export declare function resolveTask(task: EvalTaskConfig, defaults: EvalDefaults, baseDir: string): Promise<ResolvedTask>;
+//# sourceMappingURL=config.d.ts.map

package/node_modules/skillgrade/dist/core/config.js

@@ -0,0 +1,213 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadEvalConfig = loadEvalConfig;
+exports.resolveTask = resolveTask;
+/**
+ * Parser and validator for eval.yaml config files.
+ */
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+// We use a simple YAML parser — js-yaml is the standard
+// For now, we'll use a lightweight approach: JSON-compatible YAML subset
+const DEFAULT_CONFIG = {
+    agent: 'gemini',
+    provider: 'docker',
+    trials: 5,
+    timeout: 300,
+    threshold: 0.8,
+    docker: {
+        base: 'node:20-slim',
+    },
+    environment: {
+        cpus: 2,
+        memory_mb: 2048,
+    },
+};
+/**
+ * Load and parse eval.yaml from a directory.
+ */
+async function loadEvalConfig(dir) {
+    const yamlPath = path.join(dir, 'eval.yaml');
+    if (!await fs.pathExists(yamlPath)) {
+        throw new Error(`No eval.yaml found in ${dir}`);
+    }
+    // Dynamically import js-yaml
+    let yaml;
+    try {
+        yaml = require('js-yaml');
+    }
+    catch {
+        throw new Error('js-yaml is required. Run: npm install js-yaml');
+    }
+    const content = await fs.readFile(yamlPath, 'utf-8');
+    const raw = yaml.load(content);
+    return validateConfig(raw);
+}
+/**
+ * Validate raw parsed YAML into a typed EvalConfig.
+ */
+function validateConfig(raw) {
+    if (!raw || typeof raw !== 'object') {
+        throw new Error('eval.yaml must be a YAML object');
+    }
+    const version = raw.version || '1';
+    const defaults = {
+        ...DEFAULT_CONFIG,
+        ...(raw.defaults || {}),
+        docker: {
+            ...DEFAULT_CONFIG.docker,
+            ...(raw.defaults?.docker || {}),
+        },
+        environment: {
+            ...DEFAULT_CONFIG.environment,
+            ...(raw.defaults?.environment || {}),
+        },
+    };
+    if (!raw.tasks || !Array.isArray(raw.tasks) || raw.tasks.length === 0) {
+        throw new Error('eval.yaml must have at least one task in the "tasks" array');
+    }
+    const tasks = raw.tasks.map((t, i) => {
+        if (!t.name)
+            throw new Error(`Task ${i} is missing a "name"`);
+        if (!t.instruction)
+            throw new Error(`Task "${t.name}" is missing an "instruction"`);
+        if (!t.graders || !Array.isArray(t.graders) || t.graders.length === 0) {
+            throw new Error(`Task "${t.name}" must have at least one grader`);
+        }
+        const workspace = (t.workspace || []).map((w) => {
+            if (typeof w === 'string') {
+                // Support shorthand: "fixtures/app.js" → same filename in workspace
+                return { src: w, dest: path.basename(w) };
+            }
+            if (!w.src || !w.dest) {
+                throw new Error(`Task "${t.name}" has a workspace mapping without src/dest`);
+            }
+            return { src: w.src, dest: w.dest, chmod: w.chmod };
+        });
+        return {
+            name: t.name,
+            instruction: t.instruction,
+            workspace,
+            graders: t.graders.map((g) => ({
+                type: g.type,
+                setup: g.setup,
+                run: g.run,
+                rubric: g.rubric,
+                model: g.model,
+                weight: g.weight ?? 1.0,
+            })),
+            solution: t.solution,
+            agent: t.agent,
+            provider: t.provider,
+            trials: t.trials,
+            timeout: t.timeout,
+            docker: t.docker,
+        };
+    });
+    return { version, skill: raw.skill, defaults, tasks };
+}
+/**
+ * Resolve a single task: apply defaults, resolve file references to content.
+ */
+async function resolveTask(task, defaults, baseDir) {
+    // Merge defaults with task overrides
+    const agent = task.agent || defaults.agent;
+    const provider = task.provider || defaults.provider;
+    const trials = task.trials ?? defaults.trials;
+    const timeout = task.timeout ?? defaults.timeout;
+    const docker = {
+        ...defaults.docker,
+        ...(task.docker || {}),
+    };
+    const environment = {
+        ...defaults.environment,
+        ...(task.environment || {}),
+    };
+    const grader_model = task.grader_model || defaults.grader_model;
+    // Resolve instruction — could be inline text or file path
+    const instruction = await resolveFileOrInline(task.instruction, baseDir);
+    // Resolve graders
+    const graders = await Promise.all(task.graders.map(async (g) => {
+        const resolved = {
+            type: g.type,
+            setup: g.setup,
+            model: g.model,
+            weight: g.weight,
+        };
+        if (g.type === 'deterministic' && g.run) {
+            resolved.run = await resolveFileOrInline(g.run, baseDir);
+        }
+        if (g.type === 'llm_rubric' && g.rubric) {
+            resolved.rubric = await resolveFileOrInline(g.rubric, baseDir);
+        }
+        return resolved;
+    }));
+    // Resolve solution path
+    const solution = task.solution
+        ? path.resolve(baseDir, task.solution)
+        : undefined;
+    return {
+        name: task.name,
+        instruction,
+        workspace: task.workspace || [],
+        graders,
+        solution,
+        agent,
+        provider,
+        trials,
+        timeout,
+        grader_model,
+        docker,
+        environment,
+    };
+}
+/**
+ * If value looks like a file path and the file exists, read it.
+ * Otherwise return the value as-is (inline content).
+ */
+async function resolveFileOrInline(value, baseDir) {
+    const trimmed = value.trim();
+    // Multi-line strings are always inline content
+    if (trimmed.includes('\n'))
+        return trimmed;
+    // Check if it could be a file path (no spaces except in path, has extension)
+    const candidate = path.resolve(baseDir, trimmed);
+    if (await fs.pathExists(candidate)) {
+        return (await fs.readFile(candidate, 'utf-8')).trim();
+    }
+    return trimmed;
+}
+//# sourceMappingURL=config.js.map

package/node_modules/skillgrade/dist/core/config.types.d.ts

@@ -0,0 +1,88 @@
+/**
+ * eval.yaml configuration types.
+ *
+ * These types define the schema for the eval.yaml file that developers
+ * create to define evaluation tasks for their skills.
+ */
+/** Workspace file mapping: copy a local file into the container */
+export interface WorkspaceMapping {
+    src: string;
+    dest: string;
+    chmod?: string;
+}
+/** Grader definition */
+export interface EvalGraderConfig {
+    type: 'deterministic' | 'llm_rubric';
+    setup?: string;
+    run?: string;
+    rubric?: string;
+    model?: string;
+    weight: number;
+}
+/** Docker configuration */
+export interface DockerConfig {
+    base: string;
+    setup?: string;
+}
+/** Environment resource limits */
+export interface EnvironmentConfig {
+    cpus: number;
+    memory_mb: number;
+}
+/** Single eval task */
+export interface EvalTaskConfig {
+    name: string;
+    instruction: string;
+    workspace?: WorkspaceMapping[];
+    graders: EvalGraderConfig[];
+    solution?: string;
+    agent?: string;
+    provider?: string;
+    trials?: number;
+    timeout?: number;
+    grader_model?: string;
+    docker?: DockerConfig;
+    environment?: Partial<EnvironmentConfig>;
+}
+/** Top-level defaults */
+export interface EvalDefaults {
+    agent: string;
+    provider: string;
+    trials: number;
+    timeout: number;
+    threshold: number;
+    grader_model?: string;
+    docker: DockerConfig;
+    environment: EnvironmentConfig;
+}
+/** Top-level eval.yaml */
+export interface EvalConfig {
+    version: string;
+    skill?: string;
+    defaults: EvalDefaults;
+    tasks: EvalTaskConfig[];
+}
+/** Resolved task — all defaults applied, file references resolved to content */
+export interface ResolvedTask {
+    name: string;
+    instruction: string;
+    workspace: WorkspaceMapping[];
+    graders: ResolvedGrader[];
+    solution?: string;
+    agent: string;
+    provider: string;
+    trials: number;
+    timeout: number;
+    grader_model?: string;
+    docker: DockerConfig;
+    environment: EnvironmentConfig;
+}
+export interface ResolvedGrader {
+    type: 'deterministic' | 'llm_rubric';
+    setup?: string;
+    run?: string;
+    rubric?: string;
+    model?: string;
+    weight: number;
+}
+//# sourceMappingURL=config.types.d.ts.map

package/node_modules/skillgrade/dist/core/config.types.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * eval.yaml configuration types.
+ *
+ * These types define the schema for the eval.yaml file that developers
+ * create to define evaluation tasks for their skills.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+//# sourceMappingURL=config.types.js.map

package/node_modules/skillgrade/dist/core/skills.d.ts

@@ -0,0 +1,15 @@
+export interface DetectedSkill {
+    name: string;
+    path: string;
+    skillMd: string;
+}
+/**
+ * Detect skills in the given directory.
+ *
+ * Looks in these locations (in order):
+ * 1. SKILL.md in the root directory (the dir itself IS the skill)
+ * 2. skills/{name}/SKILL.md (sub-skills)
+ * 3. .agents/skills/{name}/SKILL.md (Gemini convention)
+ */
+export declare function detectSkills(dir: string): Promise<DetectedSkill[]>;
+//# sourceMappingURL=skills.d.ts.map