javi-forge 1.6.0 → 1.7.0

package/dist/commands/skills/analysis.js

@@ -0,0 +1,211 @@
+import { CONTRADICTION_PAIRS, DEFAULT_BUDGET } from "./constants.js";
+import { detectDirectiveClash } from "./directives.js";
+import { discoverSkills, estimateTokens, parseSkillFile } from "./parsing.js";
+// ── Budget Optimization ─────────────────────────────────────────────────────
+/**
+ * Generate minimal disable sets to bring total tokens under budget.
+ * Uses a greedy approach: disable largest skills first until under budget.
+ * Returns up to 3 alternative optimization suggestions.
+ */
+export function generateBudgetOptimizations(entries, totalTokens, budget) {
+    if (totalTokens <= budget)
+        return [];
+    const excess = totalTokens - budget;
+    const suggestions = [];
+    // Strategy 1: Greedy — disable largest skills first
+    const greedy = greedyDisableSet(entries, excess);
+    suggestions.push(makeSuggestion(greedy, entries, totalTokens, budget));
+    // Strategy 2: Minimal count — find smallest number of skills to disable
+    // (try single-skill solutions first, then pairs)
+    const singles = entries.filter((e) => e.tokens >= excess);
+    if (singles.length > 0) {
+        // Pick the smallest single that still meets budget
+        const sorted = [...singles].sort((a, b) => a.tokens - b.tokens);
+        const minimal = sorted[0];
+        if (minimal.skillName !== greedy[0]?.skillName) {
+            suggestions.push(makeSuggestion([minimal], entries, totalTokens, budget));
+        }
+    }
+    // Strategy 3: If we have many small skills, show a "trim many" approach
+    // Disable the bottom 50% by token count (many small skills)
+    if (entries.length >= 4) {
+        const sortedAsc = [...entries].sort((a, b) => a.tokens - b.tokens);
+        const halfCount = Math.ceil(sortedAsc.length / 2);
+        const bottomHalf = sortedAsc.slice(0, halfCount);
+        const saved = bottomHalf.reduce((s, e) => s + e.tokens, 0);
+        if (saved >= excess) {
+            const trimSet = greedyDisableSet([...bottomHalf].sort((a, b) => b.tokens - a.tokens), excess);
+            const names = new Set(trimSet.map((e) => e.skillName));
+            const alreadySuggested = suggestions.some((s) => s.disableSkills.length === names.size &&
+                s.disableSkills.every((n) => names.has(n)));
+            if (!alreadySuggested) {
+                suggestions.push(makeSuggestion(trimSet, entries, totalTokens, budget));
+            }
+        }
+    }
+    return suggestions;
+}
+/** Greedy: pick largest entries until saved >= excess */
+function greedyDisableSet(entries, excess) {
+    const sorted = [...entries].sort((a, b) => b.tokens - a.tokens);
+    const result = [];
+    let saved = 0;
+    for (const entry of sorted) {
+        if (saved >= excess)
+            break;
+        result.push(entry);
+        saved += entry.tokens;
+    }
+    return result;
+}
+function makeSuggestion(disableSet, _allEntries, totalTokens, budget) {
+    const tokensSaved = disableSet.reduce((s, e) => s + e.tokens, 0);
+    const remaining = totalTokens - tokensSaved;
+    return {
+        disableSkills: disableSet.map((e) => e.skillName),
+        tokensSaved,
+        remainingTokens: remaining,
+        meetsbudget: remaining <= budget,
+    };
+}
+// ── Conflict Detection ──────────────────────────────────────────────────────
+/** Check if two rules contradict each other (regex pairs + directive clash) */
+export function detectRuleConflict(ruleA, ruleB) {
+    const normA = ruleA.toLowerCase().trim();
+    const normB = ruleB.toLowerCase().trim();
+    // Strategy 1: Hardcoded regex pairs (fast, high confidence)
+    for (const [patternA, patternB] of CONTRADICTION_PAIRS) {
+        if ((patternA.test(normA) && patternB.test(normB)) ||
+            (patternB.test(normA) && patternA.test(normB))) {
+            return {
+                reason: `"${ruleA.slice(0, 60)}" vs "${ruleB.slice(0, 60)}"`,
+                kind: "regex-pair",
+            };
+        }
+    }
+    // Strategy 2: Semantic directive clash (broader, medium confidence)
+    const clashReason = detectDirectiveClash(ruleA, ruleB);
+    if (clashReason) {
+        return { reason: clashReason, kind: "directive-clash" };
+    }
+    return null;
+}
+/** Scan all skills for conflicting critical rules */
+export async function findConflicts(skillsDir) {
+    const skillPaths = await discoverSkills(skillsDir);
+    const allRules = [];
+    for (const sp of skillPaths) {
+        const parsed = await parseSkillFile(sp);
+        if (!parsed)
+            continue;
+        for (const rule of parsed.rules) {
+            allRules.push({
+                skillName: parsed.name,
+                skillPath: sp,
+                rule,
+                normalized: rule.toLowerCase().trim(),
+            });
+        }
+    }
+    const conflicts = [];
+    // Compare every pair (O(n^2) but skill count is small ~20-50)
+    for (let i = 0; i < allRules.length; i++) {
+        for (let j = i + 1; j < allRules.length; j++) {
+            const a = allRules[i];
+            const b = allRules[j];
+            // Skip rules from the same skill
+            if (a.skillName === b.skillName)
+                continue;
+            const result = detectRuleConflict(a.rule, b.rule);
+            if (result) {
+                conflicts.push({
+                    ruleA: a,
+                    ruleB: b,
+                    reason: result.reason,
+                    kind: result.kind,
+                });
+            }
+        }
+    }
+    return conflicts;
+}
+// ── Context Budget ──────────────────────────────────────────────────────────
+/** Calculate token budget for all installed skills */
+export async function calculateBudget(skillsDir, budget = DEFAULT_BUDGET) {
+    const skillPaths = await discoverSkills(skillsDir);
+    const entries = [];
+    for (const sp of skillPaths) {
+        const parsed = await parseSkillFile(sp);
+        if (!parsed)
+            continue;
+        entries.push({
+            skillName: parsed.name,
+            skillPath: sp,
+            tokens: estimateTokens(parsed.rawContent),
+        });
+    }
+    // Sort by token count descending (biggest consumers first)
+    entries.sort((a, b) => b.tokens - a.tokens);
+    const totalTokens = entries.reduce((sum, e) => sum + e.tokens, 0);
+    const overBudget = totalTokens > budget;
+    const suggestions = [];
+    if (overBudget) {
+        const excess = totalTokens - budget;
+        suggestions.push(`Over budget by ~${excess} tokens`);
+        // Suggest disabling the largest skills until under budget
+        let saved = 0;
+        for (const entry of entries) {
+            if (saved >= excess)
+                break;
+            suggestions.push(`Consider disabling "${entry.skillName}" (~${entry.tokens} tokens)`);
+            saved += entry.tokens;
+        }
+    }
+    const optimizations = generateBudgetOptimizations(entries, totalTokens, budget);
+    return {
+        entries,
+        totalTokens,
+        budget,
+        overBudget,
+        suggestions,
+        optimizations,
+    };
+}
+// ── Duplicate Detection ─────────────────────────────────────────────────────
+/** Find skills that overlap in scope/triggers */
+export async function findDuplicates(skillsDir) {
+    const skillPaths = await discoverSkills(skillsDir);
+    const skillData = [];
+    for (const sp of skillPaths) {
+        const parsed = await parseSkillFile(sp);
+        if (!parsed || parsed.triggers.length === 0)
+            continue;
+        skillData.push({ name: parsed.name, triggers: parsed.triggers });
+    }
+    const duplicates = [];
+    for (let i = 0; i < skillData.length; i++) {
+        for (let j = i + 1; j < skillData.length; j++) {
+            const a = skillData[i];
+            const b = skillData[j];
+            const sharedTriggers = a.triggers.filter((t) => b.triggers.some((bt) => bt.includes(t) || t.includes(bt)));
+            if (sharedTriggers.length === 0)
+                continue;
+            const maxTriggers = Math.max(a.triggers.length, b.triggers.length);
+            const similarity = maxTriggers > 0
+                ? Math.round((sharedTriggers.length / maxTriggers) * 100)
+                : 0;
+            if (similarity >= 30) {
+                duplicates.push({
+                    skillA: a.name,
+                    skillB: b.name,
+                    sharedTriggers,
+                    similarity,
+                });
+            }
+        }
+    }
+    // Sort by similarity descending
+    duplicates.sort((a, b) => b.similarity - a.similarity);
+    return duplicates;
+}
+//# sourceMappingURL=analysis.js.map

package/dist/commands/skills/benchmark.d.ts

@@ -0,0 +1,6 @@
+import type { SkillBenchmarkResult } from "../../types/index.js";
+/**
+ * Run structural quality benchmark checks against a skill.
+ */
+export declare function benchmarkSkill(skillPath: string): Promise<SkillBenchmarkResult | null>;
+//# sourceMappingURL=benchmark.d.ts.map

package/dist/commands/skills/benchmark.js

@@ -0,0 +1,82 @@
+import path from "node:path";
+import { estimateTokens, parseSkillFile } from "./parsing.js";
+import { ACTION_VERBS, VAGUE_TERMS } from "./rules.js";
+// ── Skill benchmarking ──────────────────────────────────────────────────────
+/**
+ * Run structural quality benchmark checks against a skill.
+ */
+export async function benchmarkSkill(skillPath) {
+    const parsed = await parseSkillFile(skillPath);
+    if (!parsed)
+        return null;
+    const checks = [];
+    // Check 1: Has YAML frontmatter with name
+    checks.push({
+        name: "has-frontmatter-name",
+        passed: parsed.name.length > 0 &&
+            parsed.name !== path.basename(path.dirname(skillPath)),
+        detail: parsed.name.length > 0
+            ? `name: ${parsed.name}`
+            : "No explicit name in frontmatter",
+    });
+    // Check 2: Has trigger keywords
+    checks.push({
+        name: "has-triggers",
+        passed: parsed.triggers.length > 0,
+        detail: parsed.triggers.length > 0
+            ? `${parsed.triggers.length} trigger(s) found`
+            : 'No "Trigger:" in description',
+    });
+    // Check 3: Has critical rules (>= 3)
+    checks.push({
+        name: "has-critical-rules",
+        passed: parsed.rules.length >= 3,
+        detail: `${parsed.rules.length} rule(s) found`,
+    });
+    // Check 4: Rules are actionable (contain verbs)
+    const actionableRules = parsed.rules.filter((rule) => ACTION_VERBS.some((verb) => verb.test(rule)));
+    checks.push({
+        name: "rules-actionable",
+        passed: parsed.rules.length > 0 &&
+            actionableRules.length / parsed.rules.length >= 0.5,
+        detail: `${actionableRules.length}/${parsed.rules.length} rules have action verbs`,
+    });
+    // Check 5: Has code examples
+    const codeBlocks = (parsed.rawContent.match(/```/g) ?? []).length / 2;
+    checks.push({
+        name: "has-code-examples",
+        passed: codeBlocks >= 1,
+        detail: `${Math.floor(codeBlocks)} code block(s)`,
+    });
+    // Check 6: Has structured sections (headings)
+    const headings = (parsed.rawContent.match(/^#+\s/gm) ?? []).length;
+    checks.push({
+        name: "has-sections",
+        passed: headings >= 3,
+        detail: `${headings} section heading(s)`,
+    });
+    // Check 7: Token budget reasonable (< 3000 tokens)
+    const tokens = estimateTokens(parsed.rawContent);
+    checks.push({
+        name: "token-budget-ok",
+        passed: tokens <= 3000,
+        detail: `~${tokens} tokens`,
+    });
+    // Check 8: No vague terms in rules
+    const vagueRules = parsed.rules.filter((rule) => VAGUE_TERMS.some((vague) => vague.test(rule)));
+    checks.push({
+        name: "no-vague-rules",
+        passed: vagueRules.length === 0,
+        detail: vagueRules.length > 0
+            ? `${vagueRules.length} rule(s) contain vague terms`
+            : "All rules are specific",
+    });
+    const passedCount = checks.filter((c) => c.passed).length;
+    const passRate = Math.round((passedCount / checks.length) * 100);
+    return {
+        skillName: parsed.name,
+        checks,
+        passRate,
+    };
+}
+//# sourceMappingURL=benchmark.js.map

package/dist/commands/skills/constants.d.ts

@@ -0,0 +1,10 @@
+export declare const DEFAULT_SKILLS_DIR: string;
+export declare const DEFAULT_BUDGET = 8000;
+/** Approximate tokens per character (GPT/Claude rough average) */
+export declare const CHARS_PER_TOKEN = 4;
+/** Default skill quality scoring threshold */
+export declare const DEFAULT_THRESHOLD = 50;
+/** Default registry quality threshold */
+export declare const DEFAULT_REGISTRY_THRESHOLD = 60;
+export declare const CONTRADICTION_PAIRS: [RegExp, RegExp][];
+//# sourceMappingURL=constants.d.ts.map

package/dist/commands/skills/constants.js

@@ -0,0 +1,27 @@
+import path from "node:path";
+// ── Default paths and limits ────────────────────────────────────────────────
+export const DEFAULT_SKILLS_DIR = path.join(process.env.HOME ?? "~", ".claude", "skills");
+export const DEFAULT_BUDGET = 8000;
+/** Approximate tokens per character (GPT/Claude rough average) */
+export const CHARS_PER_TOKEN = 4;
+/** Default skill quality scoring threshold */
+export const DEFAULT_THRESHOLD = 50;
+/** Default registry quality threshold */
+export const DEFAULT_REGISTRY_THRESHOLD = 60;
+// ── Contradiction keywords (pairs that signal opposite intent) ───────────────
+export const CONTRADICTION_PAIRS = [
+    [/\buse semicolons\b/i, /\bno semicolons\b/i],
+    [/\bsemicolons required\b/i, /\bno semicolons\b/i],
+    [/\bsingle quotes\b/i, /\bdouble quotes\b/i],
+    [/\btabs\b/i, /\bspaces\b/i],
+    [/\b2[- ]?spaces?\b/i, /\b4[- ]?spaces?\b/i],
+    [/\bclass[- ]?based\b/i, /\bfunctional\b/i],
+    [/\bOOP\b/i, /\bfunctional\b/i],
+    [/\bmutable\b/i, /\bimmutable\b/i],
+    [/\bany\b.*\ballowed\b/i, /\bno any\b/i],
+    [/\bdefault export\b/i, /\bnamed export\b/i],
+    [/\bnever use\b/i, /\balways use\b/i],
+    [/\bavoid\b/i, /\bprefer\b/i],
+    [/\bdo not\b/i, /\bmust\b/i],
+];
+//# sourceMappingURL=constants.js.map

package/dist/commands/skills/directives.d.ts

@@ -0,0 +1,21 @@
+/** A directive is a sentiment + subject extracted from a rule */
+export interface RuleDirective {
+    sentiment: "positive" | "negative";
+    subject: string;
+}
+/**
+ * Extract a directive (sentiment + subject) from a rule string.
+ * Returns null if the rule has no clear directive.
+ */
+export declare function extractDirective(rule: string): RuleDirective | null;
+/**
+ * Check if two subjects are similar enough to be "about the same thing".
+ * Uses simple word-overlap (Jaccard-like) — no external NLP needed.
+ */
+export declare function subjectsSimilar(a: string, b: string, threshold?: number): boolean;
+/**
+ * Detect a directive clash between two rules:
+ * opposite sentiments about the same subject.
+ */
+export declare function detectDirectiveClash(ruleA: string, ruleB: string): string | null;
+//# sourceMappingURL=directives.d.ts.map

package/dist/commands/skills/directives.js

@@ -0,0 +1,101 @@
+// ── Directive extraction (semantic conflict detection) ─────────────────────
+/**
+ * Positive and negative signal patterns.
+ * Order matters — first match wins, so more specific patterns go first.
+ */
+const POSITIVE_SIGNALS = [
+    /\balways use\b/i,
+    /\bmust use\b/i,
+    /\bprefer\b/i,
+    /\balways\b/i,
+    /\bmust\b/i,
+    /\brequire\b/i,
+    /\buse\b/i,
+    /\benable\b/i,
+    /\bshould\b/i,
+];
+const NEGATIVE_SIGNALS = [
+    /\bnever use\b/i,
+    /\bdo not use\b/i,
+    /\bdon't use\b/i,
+    /\bnever\b/i,
+    /\bavoid\b/i,
+    /\bdo not\b/i,
+    /\bdon't\b/i,
+    /\bdisable\b/i,
+    /\bno\b/i,
+    /\bforbid\b/i,
+];
+/**
+ * Extract a directive (sentiment + subject) from a rule string.
+ * Returns null if the rule has no clear directive.
+ */
+export function extractDirective(rule) {
+    const norm = rule.toLowerCase().trim();
+    // Try negative first (more specific: "never use X" before "use X")
+    for (const pattern of NEGATIVE_SIGNALS) {
+        const match = norm.match(pattern);
+        if (match) {
+            const subject = norm
+                .slice((match.index ?? 0) + match[0].length)
+                .trim()
+                .replace(/^(the|a|an)\s+/i, "")
+                .replace(/[.;,!]+$/, "")
+                .trim();
+            if (subject.length >= 3) {
+                return { sentiment: "negative", subject };
+            }
+        }
+    }
+    for (const pattern of POSITIVE_SIGNALS) {
+        const match = norm.match(pattern);
+        if (match) {
+            const subject = norm
+                .slice((match.index ?? 0) + match[0].length)
+                .trim()
+                .replace(/^(the|a|an)\s+/i, "")
+                .replace(/[.;,!]+$/, "")
+                .trim();
+            if (subject.length >= 3) {
+                return { sentiment: "positive", subject };
+            }
+        }
+    }
+    return null;
+}
+/**
+ * Check if two subjects are similar enough to be "about the same thing".
+ * Uses simple word-overlap (Jaccard-like) — no external NLP needed.
+ */
+export function subjectsSimilar(a, b, threshold = 0.5) {
+    const wordsA = new Set(a.split(/\s+/).filter((w) => w.length > 2));
+    const wordsB = new Set(b.split(/\s+/).filter((w) => w.length > 2));
+    if (wordsA.size === 0 || wordsB.size === 0)
+        return false;
+    let intersection = 0;
+    for (const w of wordsA) {
+        if (wordsB.has(w))
+            intersection++;
+    }
+    const union = new Set([...wordsA, ...wordsB]).size;
+    return union > 0 && intersection / union >= threshold;
+}
+/**
+ * Detect a directive clash between two rules:
+ * opposite sentiments about the same subject.
+ */
+export function detectDirectiveClash(ruleA, ruleB) {
+    const dA = extractDirective(ruleA);
+    const dB = extractDirective(ruleB);
+    if (!dA || !dB)
+        return null;
+    if (dA.sentiment === dB.sentiment)
+        return null;
+    if (subjectsSimilar(dA.subject, dB.subject)) {
+        const posRule = dA.sentiment === "positive" ? ruleA : ruleB;
+        const negRule = dA.sentiment === "negative" ? ruleA : ruleB;
+        return `Directive clash on "${dA.subject}": positive="${posRule.slice(0, 50)}" vs negative="${negRule.slice(0, 50)}"`;
+    }
+    return null;
+}
+//# sourceMappingURL=directives.js.map

package/dist/commands/skills/parsing.d.ts

@@ -0,0 +1,16 @@
+/** Estimate token count from a string */
+export declare function estimateTokens(text: string): number;
+/** Read a SKILL.md and extract its name + critical rules section */
+export declare function parseSkillFile(skillPath: string): Promise<{
+    name: string;
+    rules: string[];
+    rawContent: string;
+    triggers: string[];
+} | null>;
+/** Extract critical rules from markdown content */
+export declare function extractCriticalRules(content: string): string[];
+/** Extract trigger keywords from a skill description */
+export declare function extractTriggers(description: string): string[];
+/** Discover all SKILL.md files in a skills directory */
+export declare function discoverSkills(skillsDir: string): Promise<string[]>;
+//# sourceMappingURL=parsing.d.ts.map

package/dist/commands/skills/parsing.js

@@ -0,0 +1,108 @@
+import path from "node:path";
+import fs from "fs-extra";
+import { parseFrontmatter } from "../../lib/frontmatter.js";
+import { CHARS_PER_TOKEN } from "./constants.js";
+// ── Helpers ──────────────────────────────────────────────────────────────────
+/** Estimate token count from a string */
+export function estimateTokens(text) {
+    return Math.ceil(text.length / CHARS_PER_TOKEN);
+}
+/** Read a SKILL.md and extract its name + critical rules section */
+export async function parseSkillFile(skillPath) {
+    if (!(await fs.pathExists(skillPath)))
+        return null;
+    const raw = await fs.readFile(skillPath, "utf-8");
+    const fm = parseFrontmatter(raw);
+    const rawName = fm?.data?.name;
+    const name = typeof rawName === "string"
+        ? rawName
+        : path.basename(path.dirname(skillPath));
+    // Extract critical rules — look for "Critical Rules" or numbered list after it
+    const rules = extractCriticalRules(fm?.content ?? raw);
+    // Extract trigger keywords from description
+    const rawDesc = fm?.data?.description;
+    const description = typeof rawDesc === "string" ? rawDesc : "";
+    const triggers = extractTriggers(description);
+    return { name, rules, rawContent: raw, triggers };
+}
+/** Extract critical rules from markdown content */
+export function extractCriticalRules(content) {
+    const rules = [];
+    // Strategy 1: Find "Critical Rules" or "## Critical Rules" section
+    const block1 = extractSection(content, /Critical Rules?/i);
+    if (block1) {
+        extractListItems(block1, rules);
+    }
+    // Strategy 2: If no critical rules section, look for rules/conventions in any section
+    if (rules.length === 0) {
+        const block2 = extractSection(content, /Rules?/i);
+        if (block2) {
+            extractListItems(block2, rules);
+        }
+    }
+    return rules;
+}
+/** Extract a markdown section body by heading pattern */
+function extractSection(content, headingPattern) {
+    const lines = content.split("\n");
+    let capturing = false;
+    const blockLines = [];
+    for (const line of lines) {
+        if (capturing) {
+            // Stop at next heading
+            if (/^#+\s/.test(line) || /^---/.test(line))
+                break;
+            blockLines.push(line);
+        }
+        else if (/^#+\s/.test(line) && headingPattern.test(line)) {
+            capturing = true;
+        }
+    }
+    return blockLines.length > 0 ? blockLines.join("\n") : null;
+}
+/** Extract numbered or bulleted list items from a markdown block */
+function extractListItems(block, out) {
+    const lines = block.split("\n");
+    for (const line of lines) {
+        const match = line.match(/^\s*(?:\d+[.)]\s+|-\s+|\*\s+)(.+)/);
+        if (match) {
+            const cleaned = match[1].trim();
+            if (cleaned.length > 5)
+                out.push(cleaned);
+        }
+    }
+}
+/** Extract trigger keywords from a skill description */
+export function extractTriggers(description) {
+    const triggerMatch = description.match(/Trigger:\s*(.+)/i);
+    if (!triggerMatch)
+        return [];
+    const triggerText = triggerMatch[1];
+    // Split on commas, "or", "and", common delimiters
+    const keywords = triggerText
+        .split(/[,;]|\bor\b/i)
+        .map((k) => k
+        .trim()
+        .toLowerCase()
+        .replace(/^when\s+/i, ""))
+        .filter((k) => k.length > 2);
+    return keywords;
+}
+// ── Core: Scan installed skills ─────────────────────────────────────────────
+/** Discover all SKILL.md files in a skills directory */
+export async function discoverSkills(skillsDir) {
+    if (!(await fs.pathExists(skillsDir)))
+        return [];
+    const entries = await fs.readdir(skillsDir);
+    const skillFiles = [];
+    for (const entry of entries) {
+        if (entry.startsWith(".") || entry.startsWith("_"))
+            continue;
+        const skillPath = path.join(skillsDir, entry, "SKILL.md");
+        if (await fs.pathExists(skillPath)) {
+            skillFiles.push(skillPath);
+        }
+    }
+    return skillFiles.sort();
+}
+//# sourceMappingURL=parsing.js.map

package/dist/commands/skills/rules.d.ts

@@ -0,0 +1,5 @@
+/** Vague terms that reduce clarity score */
+export declare const VAGUE_TERMS: RegExp[];
+/** Action verbs that indicate actionable rules */
+export declare const ACTION_VERBS: RegExp[];
+//# sourceMappingURL=rules.d.ts.map

package/dist/commands/skills/rules.js

@@ -0,0 +1,32 @@
+// ── Skill rules lexicons ────────────────────────────────────────────────────
+/** Vague terms that reduce clarity score */
+export const VAGUE_TERMS = [
+    /\bstuff\b/i,
+    /\bthings?\b/i,
+    /\betc\.?\b/i,
+    /\bmisc\b/i,
+    /\bvarious\b/i,
+    /\bsome\b/i,
+    /\bmaybe\b/i,
+    /\bprobably\b/i,
+];
+/** Action verbs that indicate actionable rules */
+export const ACTION_VERBS = [
+    /\buse\b/i,
+    /\bavoid\b/i,
+    /\bprefer\b/i,
+    /\bnever\b/i,
+    /\balways\b/i,
+    /\bmust\b/i,
+    /\bshould\b/i,
+    /\bshall\b/i,
+    /\bensure\b/i,
+    /\bwrite\b/i,
+    /\bcreate\b/i,
+    /\bfollow\b/i,
+    /\bdo not\b/i,
+    /\bapply\b/i,
+    /\bimplement\b/i,
+    /\brun\b/i,
+];
+//# sourceMappingURL=rules.js.map

package/dist/commands/skills/scoring.d.ts

@@ -0,0 +1,47 @@
+import type { SkillGrade, SkillRegistryGateResult, SkillScore } from "../../types/index.js";
+type ParsedSkill = {
+    name: string;
+    rules: string[];
+    rawContent: string;
+    triggers: string[];
+};
+/**
+ * Score completeness (0-100): frontmatter fields, critical rules, structure.
+ */
+export declare function scoreCompleteness(parsed: ParsedSkill): number;
+/**
+ * Score clarity (0-100): description quality, rule actionability, no vague terms.
+ */
+export declare function scoreClarity(parsed: ParsedSkill): number;
+/**
+ * Score testability (0-100): Given/When/Then scenarios, specific rules.
+ */
+export declare function scoreTestability(parsed: ParsedSkill): number;
+/**
+ * Score token efficiency (0-100): information density (rules per 1000 tokens).
+ */
+export declare function scoreTokenEfficiency(parsed: ParsedSkill): number;
+/**
+ * Score safety (0-100): absence of dangerous patterns, injection risks, credential leaks.
+ * Starts at 100 and deducts for each dangerous pattern found.
+ */
+export declare function scoreSafety(parsed: ParsedSkill): number;
+/**
+ * Score agent readiness (0-100): how well-prepared a skill is for AI agent consumption.
+ * Checks for triggers, tool restrictions, examples, structured output, and error handling.
+ */
+export declare function scoreAgentReadiness(parsed: ParsedSkill): number;
+/**
+ * Convert numeric score to letter grade.
+ */
+export declare function computeGrade(overall: number): SkillGrade;
+/**
+ * Score a skill on all 6 dimensions and compute overall with letter grade.
+ */
+export declare function scoreSkill(skillPath: string, threshold?: number): Promise<SkillScore | null>;
+/**
+ * Gate check for registry inclusion. Rejects skills below the configured threshold.
+ */
+export declare function registryGate(skillPath: string, threshold?: number): Promise<SkillRegistryGateResult | null>;
+export {};
+//# sourceMappingURL=scoring.d.ts.map