@fede0089/skill-eval 1.0.0 → 1.1.0

package/dist/index.js

@@ -40,6 +40,7 @@ program
     .option('--trials <number>', 'Number of trials per task for pass@k calculation')
     .option('--timeout <seconds>', 'Agent timeout in seconds')
     .option('--eval-id <id>', 'Run only the eval with this ID (numeric)')
+    .option('--compare-ref [refs...]', 'Compare against historical git references')
     .action((agent, options) => {
     const workspace = path.resolve(options.workspace);
     const selectedAgent = agent || DEFAULT_AGENT;
@@ -47,7 +48,8 @@ program
     const numTrials = options.trials !== undefined ? (parseInt(options.trials, 10) || 3) : 3;
     const timeoutMs = options.timeout ? parseInt(options.timeout, 10) * 1000 : undefined;
     const evalId = options.evalId !== undefined ? parseInt(options.evalId, 10) : undefined;
-    triggerCommand(selectedAgent, workspace, options.skill, maxAgents, undefined, numTrials, new HtmlReporter(), timeoutMs, evalId).catch(errorHandler);
+    const compareRefs = options.compareRef || [];
+    triggerCommand(selectedAgent, workspace, options.skill, maxAgents, undefined, numTrials, new HtmlReporter(), timeoutMs, evalId, compareRefs).catch(errorHandler);
 });
 program
     .command('functional [agent]')
@@ -58,6 +60,7 @@ program
     .option('--trials <number>', 'Number of trials per task for pass@k calculation')
     .option('--timeout <seconds>', 'Agent timeout in seconds')
     .option('--eval-id <id>', 'Run only the eval with this ID (numeric)')
+    .option('--compare-ref [refs...]', 'Compare against historical git references')
     .action((agent, options) => {
     const workspace = path.resolve(options.workspace);
     const selectedAgent = agent || DEFAULT_AGENT;
@@ -65,7 +68,8 @@ program
     const numTrials = options.trials !== undefined ? (parseInt(options.trials, 10) || 3) : 3;
     const timeoutMs = options.timeout ? parseInt(options.timeout, 10) * 1000 : undefined;
     const evalId = options.evalId !== undefined ? parseInt(options.evalId, 10) : undefined;
-    functionalCommand(selectedAgent, workspace, options.skill, maxAgents, undefined, numTrials, new HtmlReporter(), timeoutMs, evalId).catch(errorHandler);
+    const compareRefs = options.compareRef || [];
+    functionalCommand(selectedAgent, workspace, options.skill, maxAgents, undefined, numTrials, new HtmlReporter(), timeoutMs, evalId, compareRefs).catch(errorHandler);
 });
 const isMain = process.argv[1] && (() => {
     try {

package/dist/reporters/html-reporter.js

@@ -32,7 +32,7 @@ function passColorClass(val) {
     return 'red';
 }
 function isFunctional(report) {
-    return report.metrics.withoutSkillScore !== undefined;
+    return report.metrics.assertionPassRate['baseline'] !== undefined;
 }
 // ---------------------------------------------------------------------------
 // Metrics Grid
@@ -47,71 +47,44 @@ function renderDeltaCell(base, target, format, cellClass) {
     return `<span class="${cellClass} ${cls}">${sign}${pct}%</span>`;
 }
 function renderMetricsGrid(report) {
-    const { metrics } = report;
+    const { metrics, results } = report;
     const functional = isFunctional(report);
-    if (functional) {
-        const bk = metrics.withoutSkillAssertionPassRate ?? metrics.withoutSkillPassAtK ?? 0;
-        const tk = metrics.assertionPassRate ?? metrics.passAtK ?? 0;
-        const upliftRaw = parseInt(metrics.skillUplift ?? '0', 10);
-        const upliftClass = upliftRaw > 0 ? 'green' : upliftRaw < 0 ? 'red' : '';
-        const wo = metrics.tokenStats?.withoutSkill;
-        const wi = metrics.tokenStats?.withSkill;
-        const wod = metrics.durationStats?.withoutSkill;
-        const wid = metrics.durationStats?.withSkill;
-        return `<div class="metrics-grid">
+    const skillVersions = results.length > 0 ? Object.keys(results[0].skillTrials) : ['local'];
+    const allVersions = functional ? ['baseline', ...skillVersions] : skillVersions;
+    const headerCells = allVersions.map(v => `<th>${v}</th>`).join('');
+    const successRows = `<tr>
+    <td>Success Rate</td>
+    ${allVersions.map(v => {
+        const val = metrics.assertionPassRate[v] ?? metrics.passAtK[v] ?? 0;
+        return `<td><span class="metric-val ${passColorClass(val)}">${formatPercent(val)}</span></td>`;
+    }).join('')}
+  </tr>`;
+    const tokenRows = `<tr>
+    <td>Tokens (avg)</td>
+    ${allVersions.map(v => {
+        const stats = metrics.tokenStats?.[v];
+        return `<td>${stats ? `<span class="metric-val">${formatTokens(stats.avgTotal)}</span><div class="metric-sub">avg total</div>` : '<span class="metric-val muted">—</span>'}</td>`;
+    }).join('')}
+  </tr>`;
+    const timeRows = `<tr>
+    <td>Time (avg)</td>
+    ${allVersions.map(v => {
+        const stats = metrics.durationStats?.[v];
+        return `<td>${stats ? `<span class="metric-val">${formatDuration(stats.avgMs)}</span>` : '<span class="metric-val muted">—</span>'}</td>`;
+    }).join('')}
+  </tr>`;
+    return `<div class="metrics-grid">
   <table>
     <thead>
-      <tr><th></th><th>Without Skill</th><th>With Skill</th><th>Delta</th></tr>
+      <tr><th></th>${headerCells}</tr>
     </thead>
     <tbody>
-      <tr>
-        <td>Success Rate</td>
-        <td><span class="metric-val ${passColorClass(bk)}">${formatPercent(bk)}</span></td>
-        <td><span class="metric-val ${passColorClass(tk)}">${formatPercent(tk)}</span></td>
-        <td><span class="metric-val ${upliftClass}">${escapeHtml(metrics.skillUplift ?? '0%')}</span></td>
-      </tr>
-      <tr>
-        <td>Tokens (avg)</td>
-        <td>${wo ? `<span class="metric-val">${formatTokens(wo.avgTotal)}</span><div class="metric-sub">avg total</div>` : '<span class="metric-val muted">—</span>'}</td>
-        <td>${wi ? `<span class="metric-val">${formatTokens(wi.avgTotal)}</span><div class="metric-sub">avg total</div>` : '<span class="metric-val muted">—</span>'}</td>
-        <td>${wo && wi ? renderDeltaCell(wo.avgTotal, wi.avgTotal, formatTokens, 'metric-val') : '<span class="metric-val muted">—</span>'}</td>
-      </tr>
-      <tr>
-        <td>Time (avg)</td>
-        <td>${wod ? `<span class="metric-val">${formatDuration(wod.avgMs)}</span>` : '<span class="metric-val muted">—</span>'}</td>
-        <td>${wid ? `<span class="metric-val">${formatDuration(wid.avgMs)}</span>` : '<span class="metric-val muted">—</span>'}</td>
-        <td>${wod && wid ? renderDeltaCell(wod.avgMs, wid.avgMs, formatDuration, 'metric-val') : '<span class="metric-val muted">—</span>'}</td>
-      </tr>
+      ${successRows}
+      ${tokenRows}
+      ${timeRows}
     </tbody>
   </table>
 </div>`;
-    }
-    else {
-        const k = metrics.passAtK ?? 0;
-        const wi = metrics.tokenStats?.withSkill;
-        const wid = metrics.durationStats?.withSkill;
-        return `<div class="metrics-grid">
-  <table>
-    <thead>
-      <tr><th></th><th>Score</th></tr>
-    </thead>
-    <tbody>
-      <tr>
-        <td>Success Rate</td>
-        <td><span class="metric-val ${passColorClass(k)}">${formatPercent(k)}</span></td>
-      </tr>
-      <tr>
-        <td>Tokens (avg)</td>
-        <td>${wi ? `<span class="metric-val">${formatTokens(wi.avgTotal)}</span><div class="metric-sub">avg total</div>` : '<span class="metric-val muted">—</span>'}</td>
-      </tr>
-      <tr>
-        <td>Time (avg)</td>
-        <td>${wid ? `<span class="metric-val">${formatDuration(wid.avgMs)}</span>` : '<span class="metric-val muted">—</span>'}</td>
-      </tr>
-    </tbody>
-  </table>
-</div>`;
-    }
 }
 // ---------------------------------------------------------------------------
 // Trial details
@@ -160,63 +133,58 @@ function avgTrialDuration(trials) {
         return null;
     return Math.round(withDuration.reduce((s, t) => s + t.durationMs, 0) / withDuration.length);
 }
-function renderTaskMiniGrid(result) {
-    const woTrials = result.withoutSkillTrials ?? [];
-    const wiTrials = result.trials;
-    const bk = woTrials.length ? Math.round(computeAssertionPassRate(woTrials) * 100) : 0;
-    const tk = wiTrials.length ? Math.round(computeAssertionPassRate(wiTrials) * 100) : 0;
-    const rateDelta = tk - bk;
-    const rateDeltaSign = rateDelta >= 0 ? '+' : '';
-    const rateDeltaClass = rateDelta > 0 ? 'green' : rateDelta < 0 ? 'red' : '';
-    const woTokens = avgTrialTokens(woTrials);
-    const wiTokens = avgTrialTokens(wiTrials);
-    const woMs = avgTrialDuration(woTrials);
-    const wiMs = avgTrialDuration(wiTrials);
-    const tokenDeltaCell = (woTokens && wiTokens)
-        ? renderDeltaCell(woTokens, wiTokens, formatTokens, 'metric-val-sm')
-        : '<span class="metric-val-sm muted">—</span>';
-    const durationDeltaCell = (woMs && wiMs)
-        ? renderDeltaCell(woMs, wiMs, formatDuration, 'metric-val-sm')
-        : '<span class="metric-val-sm muted">—</span>';
+function renderTaskMiniGrid(result, isFunctionalEval) {
+    const skillVersions = Object.keys(result.skillTrials);
+    const allVersions = isFunctionalEval ? ['baseline', ...skillVersions] : skillVersions;
+    const headerCells = allVersions.map(v => `<th>${v}</th>`).join('');
+    const successRows = `<tr>
+    <td>Success Rate</td>
+    ${allVersions.map(v => {
+        const trials = v === 'baseline' ? result.baselineTrials : result.skillTrials[v];
+        const rate = trials.length ? Math.round(computeAssertionPassRate(trials) * 100) : 0;
+        return `<td><span class="metric-val-sm ${passColorClass(rate / 100)}">${rate}%</span></td>`;
+    }).join('')}
+  </tr>`;
+    const tokenRows = `<tr>
+    <td>Tokens (avg)</td>
+    ${allVersions.map(v => {
+        const trials = v === 'baseline' ? result.baselineTrials : result.skillTrials[v];
+        const tokens = avgTrialTokens(trials);
+        return `<td>${tokens != null ? `<span class="metric-val-sm">${formatTokens(tokens)}</span>` : '<span class="metric-val-sm muted">—</span>'}</td>`;
+    }).join('')}
+  </tr>`;
+    const timeRows = `<tr>
+    <td>Time (avg)</td>
+    ${allVersions.map(v => {
+        const trials = v === 'baseline' ? result.baselineTrials : result.skillTrials[v];
+        const ms = avgTrialDuration(trials);
+        return `<td>${ms != null ? `<span class="metric-val-sm">${formatDuration(ms)}</span>` : '<span class="metric-val-sm muted">—</span>'}</td>`;
+    }).join('')}
+  </tr>`;
     return `<div class="metrics-grid-sm">
   <table>
     <thead>
-      <tr><th></th><th>Without Skill</th><th>With Skill</th><th>Delta</th></tr>
+      <tr><th></th>${headerCells}</tr>
     </thead>
     <tbody>
-      <tr>
-        <td>Success Rate</td>
-        <td><span class="metric-val-sm ${passColorClass(bk / 100)}">${bk}%</span></td>
-        <td><span class="metric-val-sm ${passColorClass(tk / 100)}">${tk}%</span></td>
-        <td><span class="metric-val-sm ${rateDeltaClass}">${rateDeltaSign}${rateDelta}%</span></td>
-      </tr>
-      <tr>
-        <td>Tokens (avg)</td>
-        <td>${woTokens != null ? `<span class="metric-val-sm">${formatTokens(woTokens)}</span>` : '<span class="metric-val-sm muted">—</span>'}</td>
-        <td>${wiTokens != null ? `<span class="metric-val-sm">${formatTokens(wiTokens)}</span>` : '<span class="metric-val-sm muted">—</span>'}</td>
-        <td>${tokenDeltaCell}</td>
-      </tr>
-      <tr>
-        <td>Time (avg)</td>
-        <td>${woMs != null ? `<span class="metric-val-sm">${formatDuration(woMs)}</span>` : '<span class="metric-val-sm muted">—</span>'}</td>
-        <td>${wiMs != null ? `<span class="metric-val-sm">${formatDuration(wiMs)}</span>` : '<span class="metric-val-sm muted">—</span>'}</td>
-        <td>${durationDeltaCell}</td>
-      </tr>
+      ${successRows}
+      ${tokenRows}
+      ${timeRows}
     </tbody>
   </table>
 </div>`;
 }
 function renderTaskDetails(result, isFunctionalEval) {
     const sections = [];
-    if (isFunctionalEval) {
-        sections.push(renderTaskMiniGrid(result));
+    sections.push(renderTaskMiniGrid(result, isFunctionalEval));
+    if (isFunctionalEval && result.baselineTrials && result.baselineTrials.length > 0) {
+        sections.push('<div class="trial-group-label">Baseline</div>');
+        sections.push(...result.baselineTrials.map(t => renderTrial(t)));
     }
-    if (isFunctionalEval && result.withoutSkillTrials && result.withoutSkillTrials.length > 0) {
-        sections.push('<div class="trial-group-label">Without Skill</div>');
-        sections.push(...result.withoutSkillTrials.map(t => renderTrial(t)));
-        sections.push('<div class="trial-group-label">With Skill</div>');
+    for (const version of Object.keys(result.skillTrials)) {
+        sections.push(`<div class="trial-group-label">${version}</div>`);
+        sections.push(...result.skillTrials[version].map(t => renderTrial(t)));
     }
-    sections.push(...result.trials.map(t => renderTrial(t)));
     return `<div class="task-details" id="details-${result.taskId}">${sections.join('')}</div>`;
 }
 // ---------------------------------------------------------------------------
@@ -241,7 +209,7 @@ export function generateHtml(report) {
     const { skill_name, agent, timestamp, metrics } = report;
     const functional = isFunctional(report);
     const evalType = functional ? 'Functional' : 'Trigger';
-    const overallScore = metrics.passAtK ?? 0;
+    const overallScore = metrics.passAtK['local'] ?? 0;
     const statusClass = passColorClass(overallScore);
     const formattedDate = new Date(timestamp).toLocaleString();
     return `<!DOCTYPE html>

package/dist/utils/exec.js

@@ -1,9 +1,16 @@
 import { execSync, spawnSync } from 'child_process';
 export const executor = {
     execSync(command, options) {
-        return execSync(command, options);
+        return execSync(command, {
+            ...options,
+            shell: process.env.SHELL || '/bin/sh',
+            env: { ...process.env, ...options?.env }
+        });
     },
     spawnSync(command, args, options) {
-        return spawnSync(command, args, options);
+        return spawnSync(command, args, {
+            ...options,
+            env: { ...process.env, ...options?.env }
+        });
     }
 };

package/dist/utils/git.js

@@ -0,0 +1,30 @@
+import path from 'path';
+import fs from 'fs';
+import { executor } from './exec.js';
+import { ExecutionError } from '../core/errors.js';
+export const git = {
+    extractSkillRef(skillPath, ref, targetDir) {
+        // 1. Identify repo root
+        let repoRoot;
+        try {
+            repoRoot = executor.execSync('git rev-parse --show-toplevel', { cwd: skillPath }).toString().trim();
+        }
+        catch (err) {
+            throw new ExecutionError(`Path is not inside a git repository: ${skillPath}`);
+        }
+        // 2. Resolve relative path of skill within repo
+        const relativeSkillPath = path.relative(repoRoot, path.resolve(skillPath));
+        // 3. Create target directory
+        fs.mkdirSync(targetDir, { recursive: true });
+        // 4. Extract via git archive
+        try {
+            const cmd = `git archive ${ref} | tar -x -C ${targetDir}`;
+            executor.execSync(cmd, { cwd: repoRoot });
+        }
+        catch (err) {
+            throw new ExecutionError(`Failed to extract git reference '${ref}': ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+};
+// Also keep named export for backward compatibility if needed
+export const extractSkillRef = git.extractSkillRef;

package/dist/utils/table-renderer.js

@@ -126,42 +126,60 @@ export function renderRunHeader(config) {
 export function renderTriggerTable(report) {
     const { results, metrics } = report;
     const numTrials = metrics.numTrials || 1;
-    const tableData = numTrials > 1
-        ? [['ID', 'Prompt', 'Trials', 'success rate']]
-        : [['ID', 'Prompt', 'success rate']];
+    // Identify all skill versions present in the results
+    const skillVersions = results.length > 0 ? Object.keys(results[0].skillTrials) : ['local'];
+    const header = ['ID', 'Prompt'];
+    if (numTrials > 1) {
+        for (const version of skillVersions) {
+            header.push(`${version} Trials`, `${version} Rate`);
+        }
+    }
+    else {
+        for (const version of skillVersions) {
+            header.push(`${version} Rate`);
+        }
+    }
+    const tableData = [header];
     let hasPartialErrors = false;
     for (const result of results) {
         const promptSnippet = result.prompt.substring(0, 40) + (result.prompt.length > 40 ? '...' : '');
-        const p1Cell = formatPassAt1(result.trials);
-        const someError = result.trials.some(t => t.isError);
-        const allError = result.trials.length > 0 && result.trials.every(t => t.isError);
-        if (someError && !allError)
-            hasPartialErrors = true;
-        if (numTrials > 1) {
-            const errorCount = result.trials.filter(t => t.isError).length;
-            const passedCount = result.trials.filter(t => t.trialPassed).length;
-            const trialsBase = `${passedCount}/${result.trials.length}`;
-            const trialsStr = errorCount > 0 ? `${trialsBase} (${errorCount}!)` : trialsBase;
-            const trials = result.score === 1.0 ? chalk.green(trialsStr) : errorCount > 0 ? chalk.yellow(trialsStr) : chalk.red(trialsStr);
-            tableData.push([result.taskId.toString(), promptSnippet, trials, p1Cell]);
-        }
-        else {
-            tableData.push([result.taskId.toString(), promptSnippet, p1Cell]);
+        const row = [result.taskId.toString(), promptSnippet];
+        for (const version of skillVersions) {
+            const trials = result.skillTrials[version] || [];
+            const p1Cell = formatPassAt1(trials);
+            const someError = trials.some(t => t.isError);
+            const allError = trials.length > 0 && trials.every(t => t.isError);
+            if (someError && !allError)
+                hasPartialErrors = true;
+            if (numTrials > 1) {
+                const errorCount = trials.filter(t => t.isError).length;
+                const passedCount = trials.filter(t => t.trialPassed).length;
+                const trialsBase = `${passedCount}/${trials.length}`;
+                const trialsStr = errorCount > 0 ? `${trialsBase} (${errorCount}!)` : trialsBase;
+                const trialsCell = passedCount === trials.length ? chalk.green(trialsStr) : errorCount > 0 ? chalk.yellow(trialsStr) : chalk.red(trialsStr);
+                row.push(trialsCell, p1Cell);
+            }
+            else {
+                row.push(p1Cell);
+            }
         }
+        tableData.push(row);
     }
     Logger.table(tableData);
     if (hasPartialErrors) {
         Logger.write(chalk.yellow('\n   * Some trials did not complete due to infrastructure errors. success rate is computed over the trials that ran.'));
     }
-    const percentage = Math.round((metrics.passAtK || 0) * 100);
-    Logger.write(`\n   Trigger Success Rate:   ${percentage}%`);
-    const withSkillTokenStats = metrics.tokenStats?.withSkill;
-    if (withSkillTokenStats) {
-        Logger.write(`\n   Avg Tokens:             ${formatTokenStatsLine(withSkillTokenStats)}`);
-    }
-    const withSkillDurationStats = metrics.durationStats?.withSkill;
-    if (withSkillDurationStats) {
-        Logger.write(`\n   Avg Time:               ${formatDuration(withSkillDurationStats.avgMs)}`);
+    for (const version of skillVersions) {
+        const percentage = Math.round((metrics.passAtK[version] || 0) * 100);
+        Logger.write(`\n   ${version} Success Rate:   ${percentage}%`);
+        const tokenStats = metrics.tokenStats?.[version];
+        if (tokenStats) {
+            Logger.write(`\n   Avg Tokens (${version}):   ${formatTokenStatsLine(tokenStats)}`);
+        }
+        const durationStats = metrics.durationStats?.[version];
+        if (durationStats) {
+            Logger.write(`\n   Avg Time (${version}):     ${formatDuration(durationStats.avgMs)}`);
+        }
     }
 }
 /**
@@ -169,61 +187,46 @@ export function renderTriggerTable(report) {
  */
 export function renderFunctionalTable(report) {
     const { results, metrics } = report;
-    const tableData = [['ID', 'Prompt', 'Without Skill', 'With Skill']];
+    // Identify all versions present (baseline + skill versions)
+    const skillVersions = results.length > 0 ? Object.keys(results[0].skillTrials) : ['local'];
+    const allVersions = ['baseline', ...skillVersions];
+    const header = ['ID', 'Prompt'];
+    for (const version of allVersions) {
+        header.push(version);
+    }
+    const tableData = [header];
     let hasPartialErrors = false;
     for (const result of results) {
         const promptSnippet = result.prompt.substring(0, 40) + (result.prompt.length > 40 ? '...' : '');
-        const withoutSkillTrials = result.withoutSkillTrials || [];
-        const withSkillTrials = result.trials;
-        const baselineSomeError = withoutSkillTrials.some(t => t.isError);
-        const baselineAllError = withoutSkillTrials.length > 0 && withoutSkillTrials.every(t => t.isError);
-        const withSkillSomeError = withSkillTrials.some(t => t.isError);
-        const withSkillAllError = withSkillTrials.length > 0 && withSkillTrials.every(t => t.isError);
-        if ((baselineSomeError && !baselineAllError) || (withSkillSomeError && !withSkillAllError))
+        const row = [result.taskId.toString(), promptSnippet];
+        // Baseline
+        const woTrials = result.baselineTrials || [];
+        if (woTrials.some(t => t.isError) && !woTrials.every(t => t.isError))
             hasPartialErrors = true;
-        tableData.push([
-            result.taskId.toString(),
-            promptSnippet,
-            formatAssertionRate(withoutSkillTrials),
-            formatAssertionRate(withSkillTrials),
-        ]);
+        row.push(formatAssertionRate(woTrials));
+        // Skills
+        for (const version of skillVersions) {
+            const wiTrials = result.skillTrials[version] || [];
+            if (wiTrials.some(t => t.isError) && !wiTrials.every(t => t.isError))
+                hasPartialErrors = true;
+            row.push(formatAssertionRate(wiTrials));
+        }
+        tableData.push(row);
     }
     Logger.table(tableData);
     if (hasPartialErrors) {
         Logger.write(chalk.yellow('\n   * Some trials did not complete due to infrastructure errors. success rate is computed over the trials that ran.'));
     }
-    const withoutSkillPercentage = Math.round(((metrics.withoutSkillAssertionPassRate ?? metrics.withoutSkillPassAtK) || 0) * 100);
-    const withSkillPercentage = Math.round(((metrics.assertionPassRate ?? metrics.passAtK) || 0) * 100);
-    Logger.write(`\n   Without Skill Rate:   ${withoutSkillPercentage}%`);
-    Logger.write(`\n   With Skill Rate:      ${withSkillPercentage}%`);
-    const baselineTokenStats = metrics.tokenStats?.withoutSkill;
-    const withSkillTokenStats = metrics.tokenStats?.withSkill;
-    if (baselineTokenStats || withSkillTokenStats) {
-        if (baselineTokenStats)
-            Logger.write(`\n   Tokens (w/o skill):   ${formatTokenStatsLine(baselineTokenStats)}`);
-        if (withSkillTokenStats)
-            Logger.write(`\n   Tokens (w/ skill):    ${formatTokenStatsLine(withSkillTokenStats)}`);
-        if (baselineTokenStats && withSkillTokenStats && baselineTokenStats.avgTotal > 0) {
-            const delta = withSkillTokenStats.avgTotal - baselineTokenStats.avgTotal;
-            const deltaSign = delta >= 0 ? '+' : '';
-            const deltaPct = Math.round((delta / baselineTokenStats.avgTotal) * 100);
-            const deltaStr = `${deltaSign}${formatTokens(Math.abs(delta))} (${deltaSign}${deltaPct}%)`;
-            Logger.write(`\n   Token Delta:          ${delta >= 0 ? chalk.yellow(deltaStr) : chalk.green(deltaStr)}`);
+    for (const version of allVersions) {
+        const rate = Math.round(((metrics.assertionPassRate[version] ?? metrics.passAtK[version]) || 0) * 100);
+        Logger.write(`\n   ${version} Rate:   ${rate}%`);
+        const stats = metrics.tokenStats?.[version];
+        if (stats) {
+            Logger.write(`\n   Tokens (${version}):   ${formatTokenStatsLine(stats)}`);
         }
-    }
-    const baselineDurationStats = metrics.durationStats?.withoutSkill;
-    const withSkillDurationStats = metrics.durationStats?.withSkill;
-    if (baselineDurationStats || withSkillDurationStats) {
-        if (baselineDurationStats)
-            Logger.write(`\n   Time (w/o skill):     ${formatDuration(baselineDurationStats.avgMs)} avg`);
-        if (withSkillDurationStats)
-            Logger.write(`\n   Time (w/ skill):      ${formatDuration(withSkillDurationStats.avgMs)} avg`);
-        if (baselineDurationStats && withSkillDurationStats && baselineDurationStats.avgMs > 0) {
-            const delta = withSkillDurationStats.avgMs - baselineDurationStats.avgMs;
-            const deltaSign = delta >= 0 ? '+' : '';
-            const deltaPct = Math.round((delta / baselineDurationStats.avgMs) * 100);
-            const deltaStr = `${deltaSign}${formatDuration(Math.abs(delta))} (${deltaSign}${deltaPct}%)`;
-            Logger.write(`\n   Time Delta:           ${delta >= 0 ? chalk.yellow(deltaStr) : chalk.green(deltaStr)}`);
+        const dStats = metrics.durationStats?.[version];
+        if (dStats) {
+            Logger.write(`\n   Time (${version}):     ${formatDuration(dStats.avgMs)} avg`);
         }
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@fede0089/skill-eval",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "CLI to evaluate agent skills triggering",
   "main": "dist/index.js",
   "bin": {
@@ -12,6 +12,9 @@
     "LICENSE"
   ],
   "scripts": {
+    "release:patch": "npm version patch && git push --follow-tags",
+    "release:minor": "npm version minor && git push --follow-tags",
+    "release:major": "npm version major && git push --follow-tags",
     "prepare": "npm run build",
     "build": "tsc",
     "start": "node dist/index.js",

package/dist/commands/rate.js

@@ -1,20 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.rateCommand = rateCommand;
-const logger_1 = require("../utils/logger");
-const errors_1 = require("../core/errors");
-async function rateCommand(score, options) {
-    const rating = parseInt(score, 10);
-    if (isNaN(rating) || rating < 1 || rating > 5) {
-        throw new errors_1.ValidationError('Rating must be a number between 1 and 5.');
-    }
-    logger_1.Logger.info('\n==========================================');
-    logger_1.Logger.info('       EXPERIENCE RATING VIEW           ');
-    logger_1.Logger.info('==========================================');
-    logger_1.Logger.info(`Rating: ${'★'.repeat(rating)}${'☆'.repeat(5 - rating)}`);
-    if (options.comment) {
-        logger_1.Logger.info(`Comment: ${options.comment}`);
-    }
-    logger_1.Logger.info('==========================================');
-    logger_1.Logger.info('Thank you for your feedback!\n');
-}

package/dist/commands/show.js

@@ -1,43 +0,0 @@
-import fs from 'fs';
-import path from 'path';
-import chalk from 'chalk';
-import { Logger } from '../utils/logger.js';
-import { AppError } from '../core/errors.js';
-import { renderTriggerTable, renderFunctionalTable } from '../utils/table-renderer.js';
-import { JsonReporter } from '../core/reporters/index.js';
-export async function showCommand(workspace, reporter = new JsonReporter()) {
-    const runsDir = path.resolve(workspace, '.project-skill-evals', 'runs');
-    if (!fs.existsSync(runsDir)) {
-        throw new AppError('No evaluation runs found. Run an evaluation first.');
-    }
-    const runs = fs.readdirSync(runsDir)
-        .filter(dir => fs.statSync(path.join(runsDir, dir)).isDirectory())
-        .sort((a, b) => b.localeCompare(a)); // Sort descending to get latest
-    if (runs.length === 0) {
-        throw new AppError('No evaluation runs found. Run an evaluation first.');
-    }
-    const latestRun = runs[0];
-    const summaryPath = path.join(runsDir, latestRun, 'summary.json');
-    if (!fs.existsSync(summaryPath)) {
-        throw new AppError(`Summary file not found for the latest run: ${latestRun}`);
-    }
-    const report = JSON.parse(fs.readFileSync(summaryPath, 'utf-8'));
-    const { skill_name, agent, metrics, results, timestamp } = report;
-    const numTrials = metrics.numTrials || 1;
-    const isFunctional = metrics.withoutSkillScore !== undefined;
-    Logger.write(`\n${chalk.bold('LATEST EVALUATION RESULTS')}\n`);
-    Logger.write(`Timestamp:  ${new Date(timestamp).toLocaleString()}\n`);
-    Logger.write(`Skill:      ${skill_name}\n`);
-    Logger.write(`Agent:      ${agent}\n`);
-    Logger.write(`Type:       ${isFunctional ? 'Functional' : 'Trigger'}\n`);
-    Logger.write(`──────────────────────────────────────────────────\n`);
-    if (isFunctional) {
-        renderFunctionalTable(report);
-    }
-    else {
-        renderTriggerTable(report);
-    }
-    Logger.write('\n');
-    const runDir = path.join(runsDir, latestRun);
-    reporter.generate(report, runDir);
-}

package/dist/commands/view.js

@@ -1,30 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.viewCommand = viewCommand;
-const logger_1 = require("../utils/logger");
-async function viewCommand(options) {
-    const ease = parseInt(options.ease || '0', 10);
-    const speed = parseInt(options.speed || '0', 10);
-    const accuracy = parseInt(options.accuracy || '0', 10);
-    const drawStars = (score) => {
-        const stars = '★'.repeat(score);
-        const empty = '☆'.repeat(5 - score);
-        return `[ ${stars}${empty} ]`;
-    };
-    logger_1.Logger.info('\n┌──────────────────────────────────────────┐');
-    logger_1.Logger.info('│          NUEVA VISTA DE CALIFICACIÓN     │');
-    logger_1.Logger.info('├──────────────────────────────────────────┤');
-    logger_1.Logger.info(`│ Facilidad de uso:   ${drawStars(ease)}     │`);
-    logger_1.Logger.info(`│ Velocidad:          ${drawStars(speed)}     │`);
-    logger_1.Logger.info(`│ Precisión:          ${drawStars(accuracy)}     │`);
-    logger_1.Logger.info('├──────────────────────────────────────────┤');
-    if (options.comment) {
-        logger_1.Logger.info(`│ Comentario:                              │`);
-        // Basic wrapping for the comment
-        const comment = options.comment.substring(0, 38);
-        logger_1.Logger.info(`│ ${comment.padEnd(40)} │`);
-    }
-    logger_1.Logger.info('├──────────────────────────────────────────┤');
-    logger_1.Logger.info('│ ¡Gracias por calificar tu experiencia!   │');
-    logger_1.Logger.info('└──────────────────────────────────────────┘\n');
-}