agent-skill-manager 1.20.0 → 1.22.0

package/node_modules/skillgrade/dist/agents/claude.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ClaudeAgent = void 0;
+const types_1 = require("../types");
+class ClaudeAgent extends types_1.BaseAgent {
+    async run(instruction, _workspacePath, runCommand) {
+        // Write instruction to a temp file to avoid shell escaping issues with long prompts
+        const b64 = Buffer.from(instruction).toString('base64');
+        await runCommand(`echo '${b64}' | base64 -d > /tmp/.prompt.md`);
+        const command = `claude -p --dangerously-skip-permissions "$(cat /tmp/.prompt.md)"`;
+        const result = await runCommand(command);
+        if (result.exitCode !== 0) {
+            console.error('ClaudeAgent: Claude failed to execute correctly.');
+        }
+        return result.stdout + '\n' + result.stderr;
+    }
+}
+exports.ClaudeAgent = ClaudeAgent;
+//# sourceMappingURL=claude.js.map

package/node_modules/skillgrade/dist/agents/codex.d.ts

@@ -0,0 +1,5 @@
+import { BaseAgent, CommandResult } from '../types';
+export declare class CodexAgent extends BaseAgent {
+    run(instruction: string, _workspacePath: string, runCommand: (cmd: string) => Promise<CommandResult>): Promise<string>;
+}
+//# sourceMappingURL=codex.d.ts.map

package/node_modules/skillgrade/dist/agents/codex.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodexAgent = void 0;
+const types_1 = require("../types");
+class CodexAgent extends types_1.BaseAgent {
+    async run(instruction, _workspacePath, runCommand) {
+        // Write instruction to a temp file to avoid shell escaping issues with long prompts
+        const b64 = Buffer.from(instruction).toString('base64');
+        await runCommand(`echo '${b64}' | base64 -d > /tmp/.prompt.md`);
+        const command = `codex --approval-mode full-auto "$(cat /tmp/.prompt.md)"`;
+        const result = await runCommand(command);
+        if (result.exitCode !== 0) {
+            console.error('CodexAgent: Codex CLI failed to execute correctly.');
+        }
+        return result.stdout + '\n' + result.stderr;
+    }
+}
+exports.CodexAgent = CodexAgent;
+//# sourceMappingURL=codex.js.map

package/node_modules/skillgrade/dist/agents/gemini.d.ts

@@ -0,0 +1,5 @@
+import { BaseAgent, CommandResult } from '../types';
+export declare class GeminiAgent extends BaseAgent {
+    run(instruction: string, _workspacePath: string, runCommand: (cmd: string) => Promise<CommandResult>): Promise<string>;
+}
+//# sourceMappingURL=gemini.d.ts.map

package/node_modules/skillgrade/dist/agents/gemini.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GeminiAgent = void 0;
+const types_1 = require("../types");
+class GeminiAgent extends types_1.BaseAgent {
+    async run(instruction, _workspacePath, runCommand) {
+        // Write instruction to a temp file to avoid shell escaping issues with long prompts
+        const b64 = Buffer.from(instruction).toString('base64');
+        await runCommand(`echo '${b64}' | base64 -d > /tmp/.prompt.md`);
+        const command = `gemini -y --sandbox=none -p "$(cat /tmp/.prompt.md)"`;
+        const result = await runCommand(command);
+        if (result.exitCode !== 0) {
+            console.error('GeminiAgent: Gemini CLI failed to execute correctly.');
+        }
+        return result.stdout + '\n' + result.stderr;
+    }
+}
+exports.GeminiAgent = GeminiAgent;
+//# sourceMappingURL=gemini.js.map

package/node_modules/skillgrade/dist/agents/registry.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Agent registry — maps agent names to their implementations.
+ *
+ * Supported agents:
+ *   - gemini: Google Gemini CLI
+ *   - claude: Anthropic Claude Code CLI
+ *   - codex: OpenAI Codex CLI
+ */
+import { BaseAgent } from '../types';
+/** Get the list of supported agent names */
+export declare function getAgentNames(): string[];
+/** Create an agent instance by name. Throws if the name is unknown. */
+export declare function createAgent(name: string): BaseAgent;
+//# sourceMappingURL=registry.d.ts.map

package/node_modules/skillgrade/dist/agents/registry.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getAgentNames = getAgentNames;
+exports.createAgent = createAgent;
+const gemini_1 = require("./gemini");
+const claude_1 = require("./claude");
+const codex_1 = require("./codex");
+/** Registry of available agent implementations */
+const AGENT_REGISTRY = {
+    gemini: () => new gemini_1.GeminiAgent(),
+    claude: () => new claude_1.ClaudeAgent(),
+    codex: () => new codex_1.CodexAgent(),
+};
+/** Get the list of supported agent names */
+function getAgentNames() {
+    return Object.keys(AGENT_REGISTRY);
+}
+/** Create an agent instance by name. Throws if the name is unknown. */
+function createAgent(name) {
+    const factory = AGENT_REGISTRY[name];
+    if (!factory) {
+        const available = getAgentNames().join(', ');
+        throw new Error(`Unknown agent "${name}". Available agents: ${available}`);
+    }
+    return factory();
+}
+//# sourceMappingURL=registry.js.map

package/node_modules/skillgrade/dist/analytics/engine.d.ts

@@ -0,0 +1,19 @@
+import { EvalReport } from '../types';
+export interface AggregateStats {
+    task: string;
+    passRateNoSkill: number;
+    passRateWithSkill: number;
+    normalizedGain: number;
+    avgDurationMs: number;
+    avgCommands: number;
+}
+/**
+ * Calculates Normalized Gain (NG) as defined in the Skill Eval paper.
+ * NG = (p_with - p_without) / (1 - p_without)
+ */
+export declare function calculateNormalizedGain(pWith: number, pWithout: number): number;
+export declare class AnalyticsEngine {
+    loadReports(logDir: string): Promise<EvalReport[]>;
+    aggregate(reports: EvalReport[]): AggregateStats[];
+}
+//# sourceMappingURL=engine.d.ts.map

package/node_modules/skillgrade/dist/analytics/engine.js

@@ -0,0 +1,105 @@
+"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.AnalyticsEngine = void 0;
+exports.calculateNormalizedGain = calculateNormalizedGain;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+/**
+ * Calculates Normalized Gain (NG) as defined in the Skill Eval paper.
+ * NG = (p_with - p_without) / (1 - p_without)
+ */
+function calculateNormalizedGain(pWith, pWithout) {
+    if (pWithout === 1) {
+        return pWith === 1 ? 0 : -1;
+    }
+    return (pWith - pWithout) / (1 - pWithout);
+}
+class AnalyticsEngine {
+    async loadReports(logDir) {
+        const files = await fs.readdir(logDir);
+        const reports = [];
+        for (const file of files) {
+            if (file.endsWith('.json')) {
+                const report = await fs.readJSON(path.join(logDir, file));
+                reports.push(report);
+            }
+        }
+        return reports;
+    }
+    aggregate(reports) {
+        const taskGroups = {};
+        for (const report of reports) {
+            if (!taskGroups[report.task]) {
+                taskGroups[report.task] = { withSkill: [], withoutSkill: [] };
+            }
+            const hasSkills = report.skills_used && report.skills_used.length > 0;
+            if (hasSkills) {
+                taskGroups[report.task].withSkill.push(report);
+            }
+            else {
+                taskGroups[report.task].withoutSkill.push(report);
+            }
+        }
+        const stats = [];
+        for (const [task, data] of Object.entries(taskGroups)) {
+            const allReports = [...data.withSkill, ...data.withoutSkill];
+            const avgWith = data.withSkill.length > 0
+                ? data.withSkill.reduce((a, b) => a + b.pass_rate, 0) / data.withSkill.length
+                : 0;
+            const avgWithout = data.withoutSkill.length > 0
+                ? data.withoutSkill.reduce((a, b) => a + b.pass_rate, 0) / data.withoutSkill.length
+                : 0;
+            const allTrials = allReports.flatMap(r => r.trials);
+            const avgDurationMs = allTrials.length > 0
+                ? allTrials.reduce((s, t) => s + (t.duration_ms || 0), 0) / allTrials.length
+                : 0;
+            const avgCommands = allTrials.length > 0
+                ? allTrials.reduce((s, t) => s + (t.n_commands || 0), 0) / allTrials.length
+                : 0;
+            stats.push({
+                task,
+                passRateWithSkill: avgWith,
+                passRateNoSkill: avgWithout,
+                normalizedGain: calculateNormalizedGain(avgWith, avgWithout),
+                avgDurationMs,
+                avgCommands
+            });
+        }
+        return stats;
+    }
+}
+exports.AnalyticsEngine = AnalyticsEngine;
+//# sourceMappingURL=engine.js.map

package/node_modules/skillgrade/dist/commands/init.d.ts

@@ -0,0 +1,4 @@
+export declare function runInit(dir: string, opts?: {
+    force?: boolean;
+}): Promise<void>;
+//# sourceMappingURL=init.d.ts.map

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

@@ -0,0 +1,335 @@
+"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.runInit = runInit;
+/**
+ * `skillgrade init` command.
+ *
+ * Detects skills in the current directory and generates an eval.yaml template.
+ * With an API key, uses an LLM to generate intelligent eval tasks.
+ * Without an API key, generates a well-commented template.
+ */
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const skills_1 = require("../core/skills");
+const env_1 = require("../utils/env");
+async function runInit(dir, opts = {}) {
+    const evalPath = path.join(dir, 'eval.yaml');
+    if (await fs.pathExists(evalPath)) {
+        if (opts.force) {
+            await fs.remove(evalPath);
+        }
+        else {
+            console.error('  eval.yaml already exists. Use --force to overwrite.');
+            throw new Error('eval.yaml already exists');
+        }
+    }
+    console.log('\nskillgrade init\n');
+    // Detect skills
+    const skills = await (0, skills_1.detectSkills)(dir);
+    if (skills.length === 0) {
+        console.log('  No SKILL.md found. Creating a generic template.');
+        console.log('     Place a SKILL.md in this directory for better scaffolding.\n');
+        await writeTemplate(evalPath, 'my-skill', 'Describe what the agent should do with this skill.');
+        return;
+    }
+    console.log(`  Found ${skills.length} skill(s): ${skills.map(s => s.name).join(', ')}\n`);
+    // Load .env file if present
+    const envPath = path.join(dir, '.env');
+    if (await fs.pathExists(envPath)) {
+        const envVars = (0, env_1.parseEnvFile)(await fs.readFile(envPath, 'utf-8'));
+        for (const [key, value] of Object.entries(envVars)) {
+            if (!process.env[key]) {
+                process.env[key] = value;
+            }
+        }
+    }
+    // Try LLM-powered scaffold — auto-detect from available API key
+    const geminiKey = process.env.GEMINI_API_KEY;
+    const anthropicKey = process.env.ANTHROPIC_API_KEY;
+    const openaiKey = process.env.OPENAI_API_KEY;
+    const llmProvider = geminiKey ? 'gemini' : anthropicKey ? 'anthropic' : openaiKey ? 'openai' : null;
+    const llmApiKey = geminiKey || anthropicKey || openaiKey;
+    const providerLabel = { gemini: 'Gemini', anthropic: 'Anthropic', openai: 'OpenAI' };
+    if (llmProvider && llmApiKey) {
+        const { Spinner, fmt } = await Promise.resolve().then(() => __importStar(require('../utils/cli')));
+        const spinner = new Spinner('init', `generating eval with ${providerLabel[llmProvider]}`);
+        try {
+            const config = await generateWithLLM(skills, llmApiKey, llmProvider);
+            await fs.writeFile(evalPath, config, 'utf-8');
+            spinner.stop(fmt.green('created eval.yaml'));
+            console.log(`     Review and edit the file, then run: skillgrade\n`);
+            return;
+        }
+        catch (err) {
+            spinner.stop(fmt.red(`AI generation failed: ${err.message}`));
+            console.log('     Falling back to template.\n');
+        }
+    }
+    else {
+        console.log('  Set GEMINI_API_KEY, ANTHROPIC_API_KEY, or OPENAI_API_KEY for AI-powered eval generation.\n');
+    }
+    // Fallback: template-based scaffold
+    const skill = skills[0];
+    const taskName = `test-${skill.name}`;
+    const instruction = extractInstructionHint(skill.skillMd);
+    await writeTemplate(evalPath, taskName, instruction);
+}
+async function writeTemplate(evalPath, taskName, instruction) {
+    const templatePath = path.join(__dirname, '..', '..', 'templates', 'eval.yaml.template');
+    let template;
+    if (await fs.pathExists(templatePath)) {
+        template = await fs.readFile(templatePath, 'utf-8');
+    }
+    else {
+        // Inline fallback if template file not found (e.g., if installed globally)
+        template = getInlineTemplate();
+    }
+    const result = template
+        .replace(/\{\{TASK_NAME\}\}/g, taskName)
+        .replace(/\{\{INSTRUCTION\}\}/g, instruction);
+    await fs.writeFile(evalPath, result, 'utf-8');
+    console.log(`  Created eval.yaml.`);
+    console.log(`     Edit the file to define your eval tasks, then run: skillgrade\n`);
+}
+/**
+ * Extract a reasonable instruction hint from SKILL.md content.
+ */
+function extractInstructionHint(skillMd) {
+    // Try to get the first paragraph after the main heading
+    const lines = skillMd.split('\n');
+    let foundHeading = false;
+    const paragraphLines = [];
+    for (const line of lines) {
+        if (line.startsWith('# ') && !foundHeading) {
+            foundHeading = true;
+            continue;
+        }
+        if (foundHeading) {
+            if (line.trim() === '' && paragraphLines.length > 0)
+                break;
+            if (line.startsWith('#'))
+                break;
+            if (line.trim())
+                paragraphLines.push(line.trim());
+        }
+    }
+    if (paragraphLines.length > 0) {
+        return `TODO: Write an instruction based on this skill.\n      Skill description: ${paragraphLines.join(' ')}`;
+    }
+    return 'TODO: Write an instruction for the agent.';
+}
+/**
+ * Generate eval.yaml content using Gemini API.
+ */
+async function generateWithLLM(skills, apiKey, provider = 'gemini') {
+    const skillSummaries = skills.map(s => `## Skill: ${s.name}\n\n${s.skillMd}`).join('\n\n---\n\n');
+    const prompt = `You are an expert at creating evaluation tasks for AI agent skills.
+
+Given the following skill definition(s), generate an eval.yaml file that defines 1-2 evaluation tasks to test whether an AI agent correctly discovers and uses the skill.
+
+For each task:
+- Write a realistic instruction (what a user would ask the agent to do)
+- Define workspace files if needed (fixture files the agent works on)
+- Write a deterministic grader (shell script that outputs JSON to stdout)
+- Write an LLM rubric (criteria for the LLM judge)
+
+IMPORTANT GRADING RULES:
+- Deterministic graders MUST output JSON to stdout: {"score": 0.0-1.0, "details": "...", "checks": [...]}
+- Do NOT use exit codes for scoring. The grader should always exit 0 and report the score in JSON.
+- Use awk for floating point arithmetic (bc is not available in node:20-slim).
+- The "checks" array is optional but recommended for per-check breakdown.
+- For workspace files, only reference files that exist in the skill directory or that the agent will create.
+
+CRITICAL — FILENAME CONSISTENCY:
+- The instruction MUST tell the agent exactly what filenames to create (e.g., "Save the result as output.txt").
+- The deterministic grader MUST only check for filenames that are explicitly mentioned in the instruction.
+- NEVER check for a hardcoded filename that the instruction does not mention — the agent will choose its own names and the grader will fail.
+- Example: if the grader checks for "output.html", the instruction must say "Save the HTML file as output.html".
+
+${skillSummaries}
+
+Respond with ONLY the eval.yaml content. Use this exact format:
+
+version: "1"
+
+defaults:
+  agent: gemini
+  provider: docker
+  trials: 5
+  timeout: 300
+  threshold: 0.8
+  docker:
+    base: node:20-slim
+
+tasks:
+  - name: <descriptive-task-name>
+    instruction: |
+      <realistic user instruction>
+      Save <expected output> as <exact-filename>.
+    workspace:
+      # Files to copy into the agent's workspace (optional).
+      # Use string shorthand or src/dest objects:
+      # - fixtures/app.js                    # copies as app.js
+      # - src: templates/viewer.html
+      #   dest: templates/viewer.html
+    graders:
+      - type: deterministic
+        run: |
+          # Check conditions and output JSON
+          passed=0
+          total=2
+          c1_pass=false c1_msg="Check 1 failed"
+          c2_pass=false c2_msg="Check 2 failed"
+
+          if <check1>; then
+            passed=$((passed + 1))
+            c1_pass=true; c1_msg="Check 1 passed"
+          fi
+
+          if <check2>; then
+            passed=$((passed + 1))
+            c2_pass=true; c2_msg="Check 2 passed"
+          fi
+
+          score=$(awk "BEGIN {printf \\"%.2f\\", $passed/$total}")
+          echo "{\\"score\\":$score,\\"details\\":\\"$passed/$total checks passed\\",\\"checks\\":[{\\"name\\":\\"check1\\",\\"passed\\":$c1_pass,\\"message\\":\\"$c1_msg\\"},{\\"name\\":\\"check2\\",\\"passed\\":$c2_pass,\\"message\\":\\"$c2_msg\\"}]}"
+        weight: 0.7
+      - type: llm_rubric
+        rubric: |
+          <evaluation criteria>
+        weight: 0.3`;
+    let text;
+    const fetchOpts = { signal: AbortSignal.timeout(120_000) };
+    if (provider === 'anthropic') {
+        const response = await fetch('https://api.anthropic.com/v1/messages', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'x-api-key': apiKey,
+                'anthropic-version': '2023-06-01',
+            },
+            body: JSON.stringify({
+                model: 'claude-sonnet-4-20250514',
+                max_tokens: 4096,
+                messages: [{ role: 'user', content: prompt }],
+                temperature: 0.3,
+            }),
+            ...fetchOpts,
+        });
+        if (!response.ok) {
+            throw new Error(`Anthropic API returned ${response.status}`);
+        }
+        const data = await response.json();
+        text = data.content?.[0]?.text;
+        if (!text)
+            throw new Error('Empty response from Anthropic API');
+    }
+    else if (provider === 'openai') {
+        const response = await fetch('https://api.openai.com/v1/chat/completions', {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+                'Authorization': `Bearer ${apiKey}`,
+            },
+            body: JSON.stringify({
+                model: 'gpt-4o',
+                max_tokens: 4096,
+                messages: [{ role: 'user', content: prompt }],
+                temperature: 0.3,
+            }),
+            ...fetchOpts,
+        });
+        if (!response.ok) {
+            throw new Error(`OpenAI API returned ${response.status}`);
+        }
+        const data = await response.json();
+        text = data.choices?.[0]?.message?.content;
+        if (!text)
+            throw new Error('Empty response from OpenAI API');
+    }
+    else {
+        const response = await fetch(`https://generativelanguage.googleapis.com/v1beta/models/gemini-3-flash-preview:generateContent?key=${apiKey}`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                contents: [{ parts: [{ text: prompt }] }],
+                generationConfig: { temperature: 0.3 },
+            }),
+            ...fetchOpts,
+        });
+        if (!response.ok) {
+            throw new Error(`Gemini API returned ${response.status}`);
+        }
+        const data = await response.json();
+        text = data.candidates?.[0]?.content?.parts?.[0]?.text;
+        if (!text)
+            throw new Error('Empty response from Gemini API');
+    }
+    // Extract YAML from response (strip markdown code fences if present)
+    const yamlContent = text.replace(/```ya?ml\n?/g, '').replace(/```\n?/g, '').trim();
+    return yamlContent + '\n';
+}
+function getInlineTemplate() {
+    return `version: "1"
+
+defaults:
+  agent: gemini
+  provider: docker
+  trials: 5
+  timeout: 300
+  threshold: 0.8
+  docker:
+    base: node:20-slim
+
+tasks:
+  - name: {{TASK_NAME}}
+    instruction: |
+      {{INSTRUCTION}}
+
+    graders:
+      - type: deterministic
+        run: |
+          # Grader must output JSON: {"score": 0.0-1.0, "details": "...", "checks": [...]}
+          echo '{"score": 0.0, "details": "TODO: implement grader"}'
+        weight: 0.7
+
+      - type: llm_rubric
+        rubric: |
+          TODO: Write evaluation criteria.
+        weight: 0.3
+`;
+}
+//# sourceMappingURL=init.js.map

package/node_modules/skillgrade/dist/commands/preview.d.ts

@@ -0,0 +1,2 @@
+export declare function runPreview(dir: string, mode: 'cli' | 'browser', outputDir?: string): Promise<void>;
+//# sourceMappingURL=preview.d.ts.map

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

@@ -0,0 +1,56 @@
+"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.runPreview = runPreview;
+/**
+ * `skillgrade preview` command.
+ *
+ * Opens the CLI or browser results viewer.
+ */
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const cli_1 = require("../reporters/cli");
+const browser_1 = require("../reporters/browser");
+async function runPreview(dir, mode, outputDir) {
+    const base = outputDir || path.join(os.tmpdir(), 'skillgrade');
+    const resultsDir = path.join(base, path.basename(dir), 'results');
+    if (mode === 'browser') {
+        await (0, browser_1.runBrowserPreview)(resultsDir);
+    }
+    else {
+        await (0, cli_1.runCliPreview)(resultsDir);
+    }
+}
+//# sourceMappingURL=preview.js.map

package/node_modules/skillgrade/dist/commands/run.d.ts

@@ -0,0 +1,16 @@
+interface RunOptions {
+    eval?: string;
+    trials?: number;
+    parallel?: number;
+    validate?: boolean;
+    ci?: boolean;
+    threshold?: number;
+    preset?: 'smoke' | 'reliable' | 'regression';
+    agent?: string;
+    provider?: string;
+    output?: string;
+    grader?: string;
+}
+export declare function runEvals(dir: string, opts: RunOptions): Promise<void>;
+export {};
+//# sourceMappingURL=run.d.ts.map