aiden-runtime 3.16.0

package/dist/core/skillTeacher.js

@@ -0,0 +1,352 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.skillTeacher = exports.SkillTeacher = void 0;
+// core/skillTeacher.ts — Self-learning skill generation.
+// After every successful plan execution, records the tool sequence,
+// generates a SKILL.md using the LLM, and promotes to "approved"
+// after PROMOTE_THRESHOLD successes.
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+// ── Paths ──────────────────────────────────────────────────────
+const LEARNED_DIR = path_1.default.join(process.cwd(), 'workspace', 'skills', 'learned');
+const APPROVED_DIR = path_1.default.join(process.cwd(), 'workspace', 'skills', 'approved');
+const BUNDLED_SKILLS_DIR = path_1.default.join(process.cwd(), 'skills');
+const PROMOTE_THRESHOLD = 3; // successes needed to promote to approved/
+const SESSION_SKILL_LIMIT = 2; // max NEW skills generated per process session
+// ── Session-scoped new-skill counter (reset on process restart) ─
+let _sessionSkillsCreated = 0;
+// ── Skill name extractor ───────────────────────────────────────
+// "research the top AI agents of 2025" → "research_ai_agents"
+function extractSkillName(task, tools) {
+    // Use tool sequence to name the skill when pattern is recognisable
+    if (tools.includes('deep_research') && tools.includes('file_write'))
+        return 'research_and_save';
+    if (tools.includes('web_search') && tools.includes('file_write'))
+        return 'search_and_save';
+    if (tools.includes('get_stocks'))
+        return 'stock_research';
+    if (tools.includes('run_python'))
+        return 'python_execution';
+    if (tools.includes('run_node'))
+        return 'node_execution';
+    if (tools.includes('shell_exec') && tools.includes('file_write'))
+        return 'shell_and_save';
+    // Extract key nouns from task — first 3 meaningful words
+    const stopWords = new Set([
+        'the', 'a', 'an', 'and', 'or', 'to', 'in', 'on',
+        'for', 'of', 'with', 'my', 'your', 'about', 'from',
+        'save', 'get', 'find', 'make', 'show', 'tell',
+    ]);
+    const words = task
+        .toLowerCase()
+        .replace(/[^a-z0-9\s]/g, ' ')
+        .split(/\s+/)
+        .filter(w => w.length > 2 && !stopWords.has(w))
+        .slice(0, 3);
+    return words.join('_') || 'general_task';
+}
+// ── SKILL.md generator ─────────────────────────────────────────
+async function generateSkillContent(skillName, task, tools, duration, llmCaller, apiKey, model, provider) {
+    const prompt = `Generate a SKILL.md file for DevOS based on this successful task execution.
+
+Task: "${task}"
+Tools used in order: ${tools.join(' → ')}
+Duration: ${Math.round(duration / 1000)}s
+
+Write a SKILL.md with this EXACT format:
+---
+name: ${skillName}
+description: [one line description of what this skill does]
+version: 1.0.0
+origin: local
+confidence: low
+tags: [comma separated tags relevant to this task]
+---
+
+# [Skill Title in Title Case]
+
+[2-5 bullet points of key instructions for doing this type of task well]
+[Include specific tips learned from this execution]
+[Keep it concise — under 200 words total]
+
+Output ONLY the SKILL.md content. No explanation.`;
+    try {
+        const content = await llmCaller(prompt, apiKey, model, provider);
+        // Validate it has valid frontmatter
+        if (content.includes('---') && content.includes('name:')) {
+            return content.trim();
+        }
+        // Fallback — minimal valid SKILL.md
+        return buildFallbackSkill(skillName, task, tools, duration);
+    }
+    catch {
+        return buildFallbackSkill(skillName, task, tools, duration);
+    }
+}
+function buildFallbackSkill(skillName, task, tools, duration) {
+    const title = skillName.replace(/_/g, ' ').replace(/\b\w/g, c => c.toUpperCase());
+    return `---
+name: ${skillName}
+description: ${task.slice(0, 80)}
+version: 1.0.0
+origin: local
+confidence: low
+tags: ${tools.join(', ')}
+---
+
+# ${title}
+
+When performing this type of task:
+1. Use tools in this order: ${tools.join(' → ')}
+2. Task completed in ~${Math.round(duration / 1000)}s
+3. Verify each step output before proceeding to the next
+`;
+}
+// ── SkillTeacher ───────────────────────────────────────────────
+class SkillTeacher {
+    constructor() {
+        try {
+            fs_1.default.mkdirSync(LEARNED_DIR, { recursive: true });
+        }
+        catch { }
+        try {
+            fs_1.default.mkdirSync(APPROVED_DIR, { recursive: true });
+        }
+        catch { }
+    }
+    static getInstance() {
+        if (!SkillTeacher.instance) {
+            SkillTeacher.instance = new SkillTeacher();
+        }
+        return SkillTeacher.instance;
+    }
+    // ── Check if a matching skill already exists ──────────────
+    hasMatchingSkill(task, tools) {
+        const skillName = extractSkillName(task, tools);
+        const dirsToCheck = [
+            path_1.default.join(process.cwd(), 'skills'),
+            LEARNED_DIR,
+            APPROVED_DIR,
+        ];
+        for (const dir of dirsToCheck) {
+            try {
+                if (fs_1.default.existsSync(dir) && fs_1.default.existsSync(path_1.default.join(dir, skillName)))
+                    return true;
+            }
+            catch { }
+        }
+        return false;
+    }
+    // ── Record a successful task ───────────────────────────────
+    async recordSuccess(task, tools, duration, llmCaller, apiKey, model, provider) {
+        if (tools.length === 0)
+            return;
+        const skillName = extractSkillName(task, tools);
+        const metaPath = path_1.default.join(LEARNED_DIR, skillName, 'meta.json');
+        const skillPath = path_1.default.join(LEARNED_DIR, skillName, 'SKILL.md');
+        // ── If skill exists — update usage count ─────────────────
+        if (fs_1.default.existsSync(metaPath)) {
+            try {
+                const meta = JSON.parse(fs_1.default.readFileSync(metaPath, 'utf-8'));
+                meta.successCount++;
+                meta.lastUsed = Date.now();
+                meta.avgDuration = Math.round((meta.avgDuration + duration) / 2);
+                meta.confidence = Math.min(meta.successCount / PROMOTE_THRESHOLD, 1);
+                if (meta.successCount >= PROMOTE_THRESHOLD && !meta.promoted) {
+                    this.promoteSkill(skillName);
+                    meta.promoted = true;
+                    console.log(`[SkillTeacher] Promoted "${skillName}" → approved/ (${meta.successCount} successes)`);
+                }
+                fs_1.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+                console.log(`[SkillTeacher] Updated "${skillName}" — ${meta.successCount} successes, confidence: ${(meta.confidence * 100).toFixed(0)}%`);
+            }
+            catch (e) {
+                console.warn(`[SkillTeacher] Meta update failed for "${skillName}": ${e.message}`);
+            }
+            return;
+        }
+        // ── Quality gate — reject low-signal skill names ──────────
+        const isLowQuality = (skillName.length < 5 ||
+            skillName.split('_').length < 2 ||
+            task.split(/\s+/).length < 3);
+        if (isLowQuality) {
+            console.log(`[SkillTeacher] Rejected low-quality skill: "${skillName}"`);
+            return;
+        }
+        // ── Session rate limit — max SESSION_SKILL_LIMIT new skills ─
+        if (_sessionSkillsCreated >= SESSION_SKILL_LIMIT) {
+            console.log(`[SkillTeacher] Session limit reached (${SESSION_SKILL_LIMIT}), skipping: "${skillName}"`);
+            return;
+        }
+        // ── Deduplication — reject names already in bundled skills/, approved/, or learned/ ─
+        const dirsToDedup = [BUNDLED_SKILLS_DIR, APPROVED_DIR, LEARNED_DIR];
+        for (const dir of dirsToDedup) {
+            if (fs_1.default.existsSync(path_1.default.join(dir, skillName))) {
+                console.log(`[SkillTeacher] Skipping duplicate (exists in ${path_1.default.basename(dir)}/): "${skillName}"`);
+                return;
+            }
+        }
+        // ── New skill — generate SKILL.md and write meta ──────────
+        console.log(`[SkillTeacher] Learning new skill: "${skillName}" from task: "${task.slice(0, 60)}"`);
+        try {
+            const content = await generateSkillContent(skillName, task, tools, duration, llmCaller, apiKey, model, provider);
+            // ── Size validation — reject suspiciously small or large content ──
+            const byteLen = Buffer.byteLength(content, 'utf-8');
+            if (byteLen < 200) {
+                console.warn(`[SkillTeacher] Rejected "${skillName}": content too small (${byteLen} bytes, min 200)`);
+                return;
+            }
+            if (byteLen > 10240) {
+                console.warn(`[SkillTeacher] Rejected "${skillName}": content too large (${byteLen} bytes > 10KB)`);
+                return;
+            }
+            // ── Structural validation — must have frontmatter + heading + body ──
+            const hasFrontmatter = (content.match(/---/g) || []).length >= 2;
+            const hasNameField = /^name:\s*\S/m.test(content);
+            const hasDescField = /^description:\s*\S/m.test(content);
+            const hasHeading = /^#\s+\S/m.test(content);
+            const hasBody = content.split('\n').filter(l => l.trim().length > 0).length >= 8;
+            if (!hasFrontmatter || !hasNameField || !hasDescField || !hasHeading || !hasBody) {
+                console.warn(`[SkillTeacher] Rejected "${skillName}": failed structural validation (frontmatter=${hasFrontmatter}, name=${hasNameField}, desc=${hasDescField}, heading=${hasHeading}, body=${hasBody})`);
+                return;
+            }
+            fs_1.default.mkdirSync(path_1.default.join(LEARNED_DIR, skillName), { recursive: true });
+            fs_1.default.writeFileSync(skillPath, content, 'utf-8');
+            const meta = {
+                name: skillName,
+                taskPattern: task.slice(0, 100),
+                toolSequence: tools,
+                successCount: 1,
+                failCount: 0,
+                confidence: 1 / PROMOTE_THRESHOLD,
+                promoted: false,
+                createdAt: Date.now(),
+                lastUsed: Date.now(),
+                avgDuration: duration,
+            };
+            fs_1.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+            _sessionSkillsCreated++;
+            console.log(`[SkillTeacher] Saved new skill: "${skillName}" (session total: ${_sessionSkillsCreated}/${SESSION_SKILL_LIMIT})`);
+            // Invalidate skillLoader cache so new skill is picked up immediately
+            try {
+                const { skillLoader } = await Promise.resolve().then(() => __importStar(require('./skillLoader')));
+                skillLoader.refresh();
+            }
+            catch { }
+        }
+        catch (e) {
+            console.warn(`[SkillTeacher] Failed to generate skill "${skillName}": ${e.message}`);
+        }
+    }
+    // ── Record a failed task ───────────────────────────────────
+    recordFailure(task, tools) {
+        if (tools.length === 0)
+            return;
+        const skillName = extractSkillName(task, tools);
+        const metaPath = path_1.default.join(LEARNED_DIR, skillName, 'meta.json');
+        if (!fs_1.default.existsSync(metaPath))
+            return;
+        try {
+            const meta = JSON.parse(fs_1.default.readFileSync(metaPath, 'utf-8'));
+            meta.failCount++;
+            fs_1.default.writeFileSync(metaPath, JSON.stringify(meta, null, 2));
+        }
+        catch { }
+    }
+    // ── Promote skill from learned/ to approved/ ───────────────
+    promoteSkill(skillName) {
+        const src = path_1.default.join(LEARNED_DIR, skillName);
+        const dest = path_1.default.join(APPROVED_DIR, skillName);
+        try {
+            fs_1.default.mkdirSync(dest, { recursive: true });
+            for (const file of fs_1.default.readdirSync(src)) {
+                fs_1.default.copyFileSync(path_1.default.join(src, file), path_1.default.join(dest, file));
+            }
+            // Invalidate cache after promotion
+            Promise.resolve().then(() => __importStar(require('./skillLoader'))).then(m => m.skillLoader.refresh()).catch(() => { });
+        }
+        catch (e) {
+            console.warn(`[SkillTeacher] Promotion failed for "${skillName}": ${e.message}`);
+        }
+    }
+    // ── List helpers ───────────────────────────────────────────
+    readDir(dir) {
+        if (!fs_1.default.existsSync(dir))
+            return [];
+        return fs_1.default.readdirSync(dir)
+            .filter(d => {
+            try {
+                return fs_1.default.statSync(path_1.default.join(dir, d)).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        })
+            .map(name => {
+            try {
+                const metaPath = path_1.default.join(dir, name, 'meta.json');
+                if (fs_1.default.existsSync(metaPath)) {
+                    return JSON.parse(fs_1.default.readFileSync(metaPath, 'utf-8'));
+                }
+                return { name, successCount: 0, failCount: 0, confidence: 0 };
+            }
+            catch {
+                return { name, successCount: 0, failCount: 0, confidence: 0 };
+            }
+        });
+    }
+    listLearned() {
+        return this.readDir(LEARNED_DIR);
+    }
+    listApproved() {
+        return this.readDir(APPROVED_DIR);
+    }
+    getStats() {
+        const learned = this.listLearned();
+        const approved = this.listApproved();
+        const totalSuccesses = learned.reduce((s, m) => s + (m.successCount || 0), 0);
+        return { learned: learned.length, approved: approved.length, totalSuccesses };
+    }
+}
+exports.SkillTeacher = SkillTeacher;
+exports.skillTeacher = SkillTeacher.getInstance();

package/dist/core/skillValidator.js

@@ -0,0 +1,210 @@
+"use strict";
+// ============================================================
+// DevOS — Autonomous AI Execution System
+// Copyright (c) 2026 Shiva Deore. All rights reserved.
+// ============================================================
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateSkillDir = validateSkillDir;
+exports.validateSkillByName = validateSkillByName;
+exports.validateAllSkills = validateAllSkills;
+exports.summariseResults = summariseResults;
+// core/skillValidator.ts — agentskills.io spec compliance validator.
+//
+// Validates a skill directory (or all loaded skills) against the
+// Open Agent Skills specification at https://agentskills.io
+//
+// Spec summary:
+//   - SKILL.md with YAML frontmatter
+//   - Required: name (^[a-z0-9]+(-[a-z0-9]+)*$), description
+//   - Recommended: license (SPDX), version (semver)
+//   - Optional subdirs: scripts/, references/, assets/
+//   - Script extensions: .py .sh .js .ts .mjs only
+//   - allowed-tools: list of tool names skill may invoke
+const fs_1 = __importDefault(require("fs"));
+const path_1 = __importDefault(require("path"));
+const skillLoader_1 = require("./skillLoader");
+// ── Constants ─────────────────────────────────────────────────
+const NAME_REGEX = /^[a-z0-9]+(-[a-z0-9]+)*$/;
+const SEMVER_REGEX = /^\d+\.\d+\.\d+(-[\w.]+)?$/;
+const SPDX_COMMON = new Set([
+    'Apache-2.0', 'MIT', 'GPL-2.0', 'GPL-3.0', 'LGPL-2.1', 'LGPL-3.0',
+    'BSD-2-Clause', 'BSD-3-Clause', 'ISC', 'MPL-2.0', 'AGPL-3.0', 'CC0-1.0',
+    'CC-BY-4.0', 'CC-BY-SA-4.0', 'Unlicense', 'WTFPL', 'Proprietary',
+]);
+const ALLOWED_SCRIPT_EXTS = new Set(['.py', '.sh', '.js', '.ts', '.mjs']);
+// ── Core validator ─────────────────────────────────────────────
+function validateSkillDir(skillDir) {
+    const skillId = path_1.default.basename(skillDir);
+    const skillPath = path_1.default.join(skillDir, 'SKILL.md');
+    const errors = [];
+    const warnings = [];
+    // ── E1: SKILL.md must exist ────────────────────────────────
+    if (!fs_1.default.existsSync(skillPath)) {
+        errors.push({ code: 'E_NO_SKILL_MD', message: 'SKILL.md not found in skill directory' });
+        return { skillId, skillPath, valid: false, errors, warnings, specScore: 0 };
+    }
+    const raw = (() => {
+        try {
+            return fs_1.default.readFileSync(skillPath, 'utf-8');
+        }
+        catch {
+            return '';
+        }
+    })();
+    if (!raw.trim()) {
+        errors.push({ code: 'E_EMPTY', message: 'SKILL.md is empty' });
+        return { skillId, skillPath, valid: false, errors, warnings, specScore: 0 };
+    }
+    // ── E2: Must have YAML frontmatter ─────────────────────────
+    const fmMatch = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n/);
+    if (!fmMatch) {
+        errors.push({ code: 'E_NO_FRONTMATTER', message: 'SKILL.md must begin with --- YAML frontmatter ---' });
+    }
+    const frontmatter = fmMatch ? fmMatch[1] : '';
+    const content = fmMatch ? raw.slice(fmMatch[0].length).trim() : raw.trim();
+    const get = (key) => {
+        const m = frontmatter.match(new RegExp(`^${key}:\\s*(.+)$`, 'm'));
+        return m ? m[1].trim().replace(/^['"]|['"]$/g, '') : '';
+    };
+    // ── E3: name — required, must match spec regex ─────────────
+    const name = get('name');
+    if (!name) {
+        errors.push({ code: 'E_NAME_MISSING', message: 'frontmatter "name:" is required', field: 'name' });
+    }
+    else if (!NAME_REGEX.test(name)) {
+        errors.push({
+            code: 'E_NAME_FORMAT',
+            message: `name "${name}" must match ^[a-z0-9]+(-[a-z0-9]+)*$ (lowercase, hyphens only, no underscores)`,
+            field: 'name',
+        });
+    }
+    else if (name !== skillId && !skillId.startsWith('generated') && !skillId.startsWith('learned')) {
+        warnings.push({
+            code: 'W_NAME_MISMATCH',
+            message: `name "${name}" does not match directory "${skillId}"`,
+            field: 'name',
+        });
+    }
+    // ── E4: description — required ─────────────────────────────
+    const description = get('description');
+    if (!description) {
+        errors.push({ code: 'E_DESC_MISSING', message: 'frontmatter "description:" is required', field: 'description' });
+    }
+    else {
+        if (description.length < 10) {
+            warnings.push({ code: 'W_DESC_SHORT', message: `description too short (${description.length} chars, recommend ≥20)`, field: 'description' });
+        }
+        if (description.length > 300) {
+            warnings.push({ code: 'W_DESC_LONG', message: `description very long (${description.length} chars, recommend ≤200)`, field: 'description' });
+        }
+    }
+    // ── W1: version — recommended, should be semver ────────────
+    const version = get('version');
+    if (!version) {
+        warnings.push({ code: 'W_VERSION_MISSING', message: 'frontmatter "version:" is recommended (e.g. "1.0.0")', field: 'version' });
+    }
+    else if (!SEMVER_REGEX.test(version)) {
+        warnings.push({ code: 'W_VERSION_FORMAT', message: `version "${version}" does not look like semver (x.y.z)`, field: 'version' });
+    }
+    // ── W2: license — recommended ──────────────────────────────
+    const license = get('license');
+    if (!license) {
+        warnings.push({ code: 'W_LICENSE_MISSING', message: 'frontmatter "license:" is recommended (e.g. "Apache-2.0")', field: 'license' });
+    }
+    else if (!SPDX_COMMON.has(license)) {
+        warnings.push({ code: 'W_LICENSE_UNKNOWN', message: `license "${license}" is not a common SPDX identifier`, field: 'license' });
+    }
+    // ── E5: Body content must exist ────────────────────────────
+    if (!content) {
+        errors.push({ code: 'E_NO_BODY', message: 'SKILL.md has frontmatter but no body content' });
+    }
+    // ── W3: Body should have at least one markdown heading ─────
+    if (content && !content.includes('#')) {
+        warnings.push({ code: 'W_NO_HEADINGS', message: 'body content has no markdown headings — consider adding structure' });
+    }
+    // ── Scripts subdir checks ───────────────────────────────────
+    const scriptsDir = path_1.default.join(skillDir, 'scripts');
+    if (fs_1.default.existsSync(scriptsDir)) {
+        try {
+            const scriptFiles = fs_1.default.readdirSync(scriptsDir);
+            for (const f of scriptFiles) {
+                const ext = path_1.default.extname(f).toLowerCase();
+                if (!ALLOWED_SCRIPT_EXTS.has(ext) && ext !== '') {
+                    errors.push({
+                        code: 'E_SCRIPT_EXT',
+                        message: `scripts/${f}: extension "${ext}" not allowed (permitted: .py .sh .js .ts .mjs)`,
+                        field: 'scripts',
+                    });
+                }
+            }
+        }
+        catch { }
+    }
+    // ── allowed-tools: validate list format ────────────────────
+    const allowedToolsRaw = get('allowed-tools');
+    if (allowedToolsRaw) {
+        const tools = allowedToolsRaw.split(',').map(t => t.trim()).filter(Boolean);
+        if (tools.length === 0) {
+            warnings.push({ code: 'W_ALLOWED_TOOLS_EMPTY', message: 'allowed-tools is set but empty', field: 'allowed-tools' });
+        }
+    }
+    // ── Score calculation ───────────────────────────────────────
+    // Start at 100, subtract per issue
+    let score = 100;
+    score -= errors.length * 15; // each error: -15
+    score -= warnings.length * 5; // each warning: -5
+    score = Math.max(0, Math.min(100, score));
+    const valid = errors.length === 0;
+    return { skillId, skillPath, valid, errors, warnings, specScore: score };
+}
+// ── Validate a single loaded skill by name ─────────────────────
+function validateSkillByName(name) {
+    const skills = skillLoader_1.skillLoader.loadAllRaw();
+    const skill = skills.find(s => s.name === name);
+    if (!skill)
+        return null;
+    return validateSkillDir(path_1.default.dirname(skill.filePath));
+}
+// ── Validate all skills in a skills directory ──────────────────
+function validateAllSkills(skillsDir) {
+    const dir = skillsDir ?? path_1.default.join(process.cwd(), 'skills');
+    if (!fs_1.default.existsSync(dir))
+        return [];
+    const results = [];
+    try {
+        const entries = fs_1.default.readdirSync(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const skillMdPath = path_1.default.join(dir, entry.name, 'SKILL.md');
+            if (!fs_1.default.existsSync(skillMdPath))
+                continue;
+            results.push(validateSkillDir(path_1.default.join(dir, entry.name)));
+        }
+    }
+    catch { }
+    return results;
+}
+function summariseResults(results) {
+    const errorCounts = {};
+    const warnCounts = {};
+    let totalScore = 0;
+    for (const r of results) {
+        totalScore += r.specScore;
+        for (const e of r.errors)
+            errorCounts[e.code] = (errorCounts[e.code] ?? 0) + 1;
+        for (const w of r.warnings)
+            warnCounts[w.code] = (warnCounts[w.code] ?? 0) + 1;
+    }
+    return {
+        total: results.length,
+        valid: results.filter(r => r.valid).length,
+        invalid: results.filter(r => !r.valid).length,
+        avgScore: results.length ? Math.round(totalScore / results.length) : 0,
+        errorCounts,
+        warnCounts,
+    };
+}