@jmtrin/kevin-core 1.4.0 → 2.0.0

package/dist/skills-emit.js

@@ -0,0 +1,421 @@
+// K15-003 — Skill bundle emitter (plan §4.1)
+// Writes <projectRoot>/<canonicalDir>/kevin-knowledge/SKILL.md + references/<topic>.md
+// Every emitted byte passes through escape helpers (C-09, K15-004).
+import { createHash, randomBytes } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, renameSync, unlinkSync, writeFileSync } from "node:fs";
+import { dirname, isAbsolute, join, resolve } from "node:path";
+import { escapeForFence, escapeForMarkerBlock } from "./escape.js";
+import { firstSentence } from "./Curator.js";
+import { resolveEnv } from "./env.js";
+import { KEVIN_VERSION } from "./index.js";
+function sha256Hex(s) {
+    return createHash("sha256").update(s, "utf8").digest("hex");
+}
+function escaped(text) {
+    // C-09 funnel: every byte through escape helpers. Apply both fence + marker (orthogonal).
+    return escapeForMarkerBlock(escapeForFence(text));
+}
+function atomicWrite(target, content) {
+    mkdirSync(dirname(target), { recursive: true });
+    const tmp = `${target}.tmp.${process.pid}.${randomBytes(4).toString("hex")}`;
+    writeFileSync(tmp, content, "utf8");
+    try {
+        renameSync(tmp, target);
+    }
+    catch (e) {
+        try {
+            unlinkSync(tmp);
+        }
+        catch { }
+        throw e;
+    }
+}
+function buildSkillMd(repoId, bundles) {
+    const header = [
+        "---",
+        "name: kevin-knowledge",
+        "description: >-",
+        "  Project knowledge curated by opencode-kevin: conventions, decisions and verified",
+        "  fixes for this repository. Load when working in this repo and unsure about local",
+        "  rules, past failures or team decisions.",
+        "metadata:",
+        `  generator: opencode-kevin/${KEVIN_VERSION}`,
+        `  repo_id: ${escaped(repoId)}`,
+        "---",
+        "",
+    ].join("\n");
+    let body;
+    if (bundles.length === 0) {
+        body = "No knowledge yet — Kevin has not curated any memories for this repository.\n\nSee `references/` when topics appear.\n";
+    }
+    else {
+        // index ≤80 lines: one per topic + header
+        const indexLines = [];
+        indexLines.push("# Kevin Knowledge");
+        indexLines.push("");
+        indexLines.push("Topics curated for this repository:");
+        indexLines.push("");
+        for (const b of bundles) {
+            const rawSummary = b.summary ?? firstSentence(b.content.split("\n").find((l) => l.trim().startsWith("-"))?.replace(/^-+\s*/, "") ?? b.content.slice(0, 120));
+            const summary = escaped(rawSummary.trim().slice(0, 140));
+            // relative link from SKILL.md to references/<topic>.md
+            indexLines.push(`- **${escaped(b.topic)}**: ${summary} — [references/${escaped(b.topic)}.md](references/${escaped(b.topic)}.md)`);
+        }
+        const MAX_INDEX = 78;
+        if (indexLines.length > MAX_INDEX) {
+            // cap at 78: truncate excess topics, reserve footer lines
+            indexLines.splice(MAX_INDEX);
+        }
+        indexLines.push("");
+        indexLines.push("See `references/` for detailed topic files.");
+        indexLines.push("");
+        body = indexLines.join("\n");
+    }
+    const full = header + body;
+    // enforce <150 lines total; if exceeds, truncate body tail via paragraph truncation
+    const lines = full.split("\n");
+    if (lines.length >= 150) {
+        const headerLines = header.split("\n").length;
+        const allowedBody = 149 - headerLines;
+        const bodyLines = body.split("\n");
+        const truncatedBody = bodyLines.slice(0, Math.max(0, allowedBody)).join("\n");
+        const truncated = header + truncatedBody;
+        return truncated.endsWith("\n") ? truncated : truncated + "\n";
+    }
+    return full;
+}
+function buildToWrite(input) {
+    const canonicalRaw = (input.canonicalDir && input.canonicalDir.trim() !== "") ? input.canonicalDir.trim() : ".agents/skills";
+    // H-01: validate canonicalDir is relative and does not escape projectRoot
+    if (isAbsolute(canonicalRaw) || canonicalRaw.includes("..")) {
+        throw new Error(`unsafe canonicalDir: ${canonicalRaw}`);
+    }
+    const base = resolve(join(input.projectRoot, canonicalRaw, "kevin-knowledge"));
+    const projectRootResolved = resolve(input.projectRoot);
+    if (base !== projectRootResolved && !base.startsWith(projectRootResolved + "/") && !base.startsWith(projectRootResolved + "\\")) {
+        throw new Error(`canonicalDir escapes projectRoot: ${canonicalRaw}`);
+    }
+    const skillPath = join(base, "SKILL.md");
+    const refsDir = join(base, "references");
+    const bundles = [...input.topics].sort((a, b) => a.topic.localeCompare(b.topic));
+    const skillContent = buildSkillMd(input.repoId, bundles);
+    const referenceContents = new Map();
+    for (const b of bundles) {
+        let body = b.content;
+        if (body.length > 4000)
+            body = body.slice(0, 4000);
+        const esc = escaped(body);
+        referenceContents.set(b.topic, esc + (esc.endsWith("\n") ? "" : "\n"));
+    }
+    const toWrite = [];
+    toWrite.push({ path: skillPath, content: skillContent });
+    for (const [topic, content] of referenceContents) {
+        // C-01 sanitize topic by replacing [/\\:]/g with "-", replacing ".." and validating
+        let safe = topic.replace(/[/\\:]/g, "-").replace(/\.\./g, "-");
+        if (safe.includes("/") || safe.includes("\\") || safe.includes("..")) {
+            throw new Error(`unsafe topic: ${topic}`);
+        }
+        if (safe.trim() === "") {
+            throw new Error(`unsafe topic: ${topic}`);
+        }
+        toWrite.push({ path: join(refsDir, `${safe}.md`), content });
+    }
+    return { base, skillPath, refsDir, toWrite, referenceContents, skillContent, bundles };
+}
+export function emitSkillBundle(input) {
+    const { base, toWrite } = buildToWrite(input);
+    const manifestPath = input.manifestPath ?? join(resolveEnv(input.env).dataRoot, "skills-manifest.json");
+    let manifest = {};
+    let manifestExists = false;
+    let manifestCorrupt = false;
+    if (existsSync(manifestPath)) {
+        try {
+            manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+            manifestExists = true;
+        }
+        catch {
+            manifestCorrupt = true;
+            try {
+                input.metrics?.incr("skills_manifest_corrupt_total", 1);
+            }
+            catch { }
+            try {
+                const corrupt = readFileSync(manifestPath, "utf8");
+                writeFileSync(`${manifestPath}.corrupt.${Date.now()}`, corrupt, "utf8");
+            }
+            catch { }
+            manifest = {};
+            manifestExists = false;
+        }
+    }
+    const written = [];
+    const skipped_external = [];
+    const noop = [];
+    const external_edits = [];
+    const removed_orphan_manifest = [];
+    for (const w of toWrite) {
+        const freshHash = sha256Hex(w.content);
+        const manifestHash = manifest[w.path];
+        const diskExists = existsSync(w.path);
+        let diskHash = null;
+        if (diskExists) {
+            try {
+                diskHash = sha256Hex(readFileSync(w.path, "utf8"));
+            }
+            catch {
+                diskHash = null;
+            }
+        }
+        if (!diskExists) {
+            atomicWrite(w.path, w.content);
+            written.push(w.path);
+            manifest[w.path] = freshHash;
+            continue;
+        }
+        if (manifestCorrupt) {
+            if (diskHash !== null && freshHash === diskHash) {
+                noop.push(w.path);
+                manifest[w.path] = freshHash;
+            }
+            else {
+                atomicWrite(w.path, w.content);
+                written.push(w.path);
+                manifest[w.path] = freshHash;
+            }
+            continue;
+        }
+        if (manifestExists) {
+            if (manifestHash === undefined) {
+                skipped_external.push(w.path);
+                external_edits.push(w.path);
+                continue;
+            }
+            if (diskHash !== manifestHash) {
+                skipped_external.push(w.path);
+                external_edits.push(w.path);
+                continue;
+            }
+        }
+        if (diskHash !== null && freshHash === diskHash) {
+            noop.push(w.path);
+            manifest[w.path] = freshHash;
+        }
+        else {
+            atomicWrite(w.path, w.content);
+            written.push(w.path);
+            manifest[w.path] = freshHash;
+        }
+    }
+    // orphan manifest cleanup: entries under base not in current toWrite
+    for (const key of Object.keys({ ...manifest })) {
+        if (key.startsWith(base) && !toWrite.some((w) => w.path === key)) {
+            removed_orphan_manifest.push(key);
+            delete manifest[key];
+            try {
+                unlinkSync(key);
+            }
+            catch { }
+            for (const mirror of input.mirrors) {
+                const mirrorBase = mirror === "claude"
+                    ? join(input.projectRoot, ".claude", "skills", "kevin-knowledge")
+                    : join(input.projectRoot, ".cursor", "skills", "kevin-knowledge");
+                const rel = key.slice(base.length);
+                const mirrorPath = join(mirrorBase, rel);
+                try {
+                    unlinkSync(mirrorPath);
+                }
+                catch { }
+            }
+        }
+    }
+    // mirror handling — follow canonical state
+    for (const mirror of input.mirrors) {
+        const mirrorBase = mirror === "claude"
+            ? join(input.projectRoot, ".claude", "skills", "kevin-knowledge")
+            : join(input.projectRoot, ".cursor", "skills", "kevin-knowledge");
+        for (const w of toWrite) {
+            const rel = w.path.slice(base.length);
+            const mirrorPath = join(mirrorBase, rel);
+            const wasWritten = written.includes(w.path);
+            const wasNoop = noop.includes(w.path);
+            const wasSkipped = skipped_external.includes(w.path);
+            if (wasSkipped)
+                continue;
+            if (wasWritten) {
+                atomicWrite(mirrorPath, w.content);
+            }
+            else if (wasNoop) {
+                if (!existsSync(mirrorPath)) {
+                    atomicWrite(mirrorPath, w.content);
+                }
+            }
+        }
+    }
+    try {
+        // manifest already built; write LAST
+        mkdirSync(dirname(manifestPath), { recursive: true });
+        atomicWrite(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+    }
+    catch { }
+    try {
+        input.metrics?.incr("skills_emitted_total", 1);
+    }
+    catch { }
+    return { written, skipped_external, noop, removed_orphan_manifest, external_edits };
+}
+export function refreshSkillBundle(input) {
+    const { base, refsDir, toWrite, referenceContents } = buildToWrite(input);
+    const manifestPath = input.manifestPath ?? join(resolveEnv(input.env).dataRoot, "skills-manifest.json");
+    let manifest = {};
+    let manifestExists = false;
+    let manifestCorrupt = false;
+    if (existsSync(manifestPath)) {
+        try {
+            manifest = JSON.parse(readFileSync(manifestPath, "utf8"));
+            manifestExists = true;
+        }
+        catch {
+            manifestCorrupt = true;
+            try {
+                input.metrics?.incr("skills_manifest_corrupt_total", 1);
+            }
+            catch { }
+            try {
+                const corrupt = readFileSync(manifestPath, "utf8");
+                writeFileSync(`${manifestPath}.corrupt.${Date.now()}`, corrupt, "utf8");
+            }
+            catch { }
+            manifest = {};
+            manifestExists = false;
+        }
+    }
+    const written = [];
+    const skipped_external = [];
+    const noop = [];
+    const external_edits = [];
+    const removed_orphan_manifest = [];
+    // three-state per managed path
+    for (const w of toWrite) {
+        const freshHash = sha256Hex(w.content);
+        const manifestHash = manifest[w.path];
+        const diskExists = existsSync(w.path);
+        let diskHash = null;
+        if (diskExists) {
+            try {
+                diskHash = sha256Hex(readFileSync(w.path, "utf8"));
+            }
+            catch {
+                diskHash = null;
+            }
+        }
+        if (!diskExists) {
+            // deleted-file reconciliation: manifest entry without disk file → rewrite (STALE)
+            atomicWrite(w.path, w.content);
+            written.push(w.path);
+            manifest[w.path] = freshHash;
+            continue;
+        }
+        // disk exists
+        if (manifestHash === undefined) {
+            if (manifestExists && !manifestCorrupt) {
+                // missing manifest + existing file = EXTERNAL domain → skip
+                skipped_external.push(w.path);
+                external_edits.push(w.path);
+                continue;
+            }
+            // if manifest corrupt or missing (bootstrap), treat as stale: allow write below
+            if (!manifestExists && !manifestCorrupt) {
+                // no manifest yet - bootstrap case: if we are in refresh with no manifest but file exists,
+                // original behavior was EXTERNAL. Keep external for refresh when not corrupt.
+                // But for corrupt we already handled; for bootstrap we should still consider external.
+                // To preserve original spec for refresh: when manifest missing, existing file is EXTERNAL
+                if (!manifestCorrupt) {
+                    skipped_external.push(w.path);
+                    external_edits.push(w.path);
+                    continue;
+                }
+            }
+        }
+        if (manifestExists && diskHash !== manifestHash) {
+            // EXTERNAL_EDIT: disk ≠ manifest → skip
+            skipped_external.push(w.path);
+            external_edits.push(w.path);
+            continue;
+        }
+        // disk == manifest (or manifest corrupt/missing and we allowed)
+        if (diskHash !== null && freshHash === diskHash) {
+            noop.push(w.path);
+            manifest[w.path] = freshHash;
+        }
+        else {
+            // STALE: disk == manifest but inputs changed → rewrite
+            // Also for corrupt bootstrap, rewrite
+            atomicWrite(w.path, w.content);
+            written.push(w.path);
+            manifest[w.path] = freshHash;
+        }
+    }
+    // orphan manifest cleanup: entries under base not in current toWrite
+    for (const key of Object.keys({ ...manifest })) {
+        if (key.startsWith(base) && !toWrite.some((w) => w.path === key)) {
+            removed_orphan_manifest.push(key);
+            delete manifest[key];
+            try {
+                unlinkSync(key);
+            }
+            catch { }
+            for (const mirror of input.mirrors) {
+                const mirrorBase = mirror === "claude"
+                    ? join(input.projectRoot, ".claude", "skills", "kevin-knowledge")
+                    : join(input.projectRoot, ".cursor", "skills", "kevin-knowledge");
+                const rel = key.slice(base.length);
+                const mirrorPath = join(mirrorBase, rel);
+                try {
+                    unlinkSync(mirrorPath);
+                }
+                catch { }
+            }
+        }
+    }
+    // mirror handling — follow canonical state
+    for (const mirror of input.mirrors) {
+        const mirrorBase = mirror === "claude"
+            ? join(input.projectRoot, ".claude", "skills", "kevin-knowledge")
+            : join(input.projectRoot, ".cursor", "skills", "kevin-knowledge");
+        for (const w of toWrite) {
+            const rel = w.path.slice(base.length);
+            const mirrorPath = join(mirrorBase, rel);
+            const wasWritten = written.includes(w.path);
+            const wasNoop = noop.includes(w.path);
+            const wasSkipped = skipped_external.includes(w.path);
+            if (wasSkipped)
+                continue;
+            if (wasWritten) {
+                // canonical changed → mirror must match (discard external edits on mirror)
+                atomicWrite(mirrorPath, w.content);
+            }
+            else if (wasNoop) {
+                // canonical unchanged → don't touch mirror (preserve if externally edited, per spec)
+                // but if mirror missing, create it (stale projection)
+                if (!existsSync(mirrorPath)) {
+                    atomicWrite(mirrorPath, w.content);
+                }
+            }
+        }
+    }
+    // manifest written LAST
+    try {
+        mkdirSync(dirname(manifestPath), { recursive: true });
+        atomicWrite(manifestPath, JSON.stringify(manifest, null, 2) + "\n");
+    }
+    catch { }
+    if (written.length > 0) {
+        try {
+            input.metrics?.incr("skills_emitted_total", 1);
+        }
+        catch { }
+    }
+    return { written, skipped_external, noop, removed_orphan_manifest, external_edits };
+}
+// Utility for tests: expose header builder and escaping
+export const _internal = { buildSkillMd, sha256Hex, escaped };

package/dist/skills-validate.d.ts

@@ -0,0 +1,7 @@
+export interface SkillValidateResult {
+    ok: boolean;
+    errors: string[];
+    warnings: string[];
+}
+export declare function validateSkill(content: string, dirname?: string): SkillValidateResult;
+export declare function validateSkillFile(filePath: string, content: string): SkillValidateResult;

package/dist/skills-validate.js

@@ -0,0 +1,236 @@
+// K15-002 — spec-subset validator (plan §4.3, D15-07)
+// Naive YAML subset: `key: value` + one-level map for metadata + folded scalars (>-, >, |)
+// Returns {ok, errors[], warnings[]} — hard rules -> errors, soft -> warnings.
+const NAME_RE = /^[a-z0-9]([a-z0-9-]*[a-z0-9])?$/;
+const MAX_NAME_LEN = 64;
+const MIN_DESC = 1;
+const MAX_DESC = 1024;
+const MAX_BODY_LINES = 500;
+export function validateSkill(content, dirname) {
+    const errors = [];
+    const warnings = [];
+    const normalized = content.replace(/\r\n/g, "\n");
+    const lines = normalized.split("\n");
+    // frontmatter must start with ---
+    if (lines.length === 0 || lines[0].trim() !== "---") {
+        errors.push("frontmatter: missing opening '---'");
+        return { ok: false, errors, warnings };
+    }
+    // find closing ---
+    let closeIdx = -1;
+    for (let i = 1; i < lines.length; i++) {
+        if (lines[i].trim() === "---") {
+            closeIdx = i;
+            break;
+        }
+    }
+    if (closeIdx === -1) {
+        errors.push("frontmatter: missing closing '---'");
+        return { ok: false, errors, warnings };
+    }
+    const fmLines = lines.slice(1, closeIdx);
+    const bodyLines = lines.slice(closeIdx + 1);
+    const body = bodyLines.join("\n");
+    const bodyTrimmed = body.trim();
+    // parse frontmatter naive
+    const fm = {};
+    let currentParent = null;
+    let foldedKey = null;
+    let foldedBuffer = [];
+    // helper to flush folded
+    function flushFolded() {
+        if (foldedKey !== null) {
+            const joined = foldedBuffer.join(" ").trim();
+            if (currentParent === "metadata" && foldedKey) {
+                // inside metadata? folded not expected, but handle
+                const meta = fm["metadata"];
+                meta[foldedKey] = joined;
+            }
+            else if (foldedKey) {
+                fm[foldedKey] = joined;
+            }
+            foldedKey = null;
+            foldedBuffer = [];
+        }
+    }
+    for (let idx = 0; idx < fmLines.length; idx++) {
+        const raw = fmLines[idx];
+        // if we are in folded collection, indented lines are continuation
+        if (foldedKey !== null) {
+            if (/^\s+/.test(raw) && raw.trim() !== "") {
+                foldedBuffer.push(raw.trim());
+                continue;
+            }
+            else {
+                // end of folded block
+                flushFolded();
+                // fall through to parse current line normally
+            }
+        }
+        if (raw.trim() === "")
+            continue;
+        // indented means metadata child or continuation already handled
+        const indentMatch = raw.match(/^(\s+)(.*)$/);
+        if (indentMatch && indentMatch[1].length >= 2) {
+            const inner = indentMatch[2];
+            if (currentParent !== "metadata") {
+                errors.push(`frontmatter: unexpected indent at line ${idx + 2}`);
+                continue;
+            }
+            const m = inner.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+            if (!m) {
+                errors.push(`frontmatter: invalid metadata line '${raw.trim()}'`);
+                continue;
+            }
+            const k = m[1];
+            const v = m[2].trim();
+            // strip surrounding quotes if present for storage but keep raw for type check
+            const stored = stripQuotes(v);
+            // detect folded for metadata? not needed
+            const meta = fm["metadata"];
+            // keep raw detection for non-string check: if v is unquoted number/boolean
+            // we still store but flag later; store raw trimmed
+            meta[k] = stored;
+            // also keep raw for validation via separate map
+            // we store raw in a hidden map
+            if (!fm.__metaRaw)
+                fm.__metaRaw = {};
+            fm.__metaRaw[k] = v;
+            continue;
+        }
+        // top-level key: value
+        const m = raw.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+        if (!m) {
+            errors.push(`frontmatter: invalid line '${raw.trim()}'`);
+            continue;
+        }
+        const key = m[1];
+        const val = m[2].trim();
+        // handle folded scalar indicators
+        if (val === ">-" || val === ">" || val === "|" || val === "|-") {
+            foldedKey = key;
+            foldedBuffer = [];
+            // initialize parent tracking if key is metadata (but folded metadata not expected)
+            if (key === "metadata") {
+                // metadata with folded? treat as empty then parent
+                fm[key] = {};
+                currentParent = "metadata";
+            }
+            else {
+                currentParent = null;
+                fm[key] = ""; // placeholder, will be filled on flush
+            }
+            continue;
+        }
+        if (key === "metadata") {
+            // metadata: may be empty (map follows) or inline? We support only map form.
+            const normalizedVal = val.trim();
+            const compactVal = normalizedVal.replace(/\s/g, "");
+            if (normalizedVal === "" || normalizedVal === "{}" || compactVal === "{}") {
+                fm[key] = {};
+                currentParent = "metadata";
+                // init raw map
+                fm.__metaRaw = {};
+            }
+            else {
+                errors.push("frontmatter: metadata must be a map");
+                fm[key] = val;
+                currentParent = null;
+            }
+            continue;
+        }
+        // normal key
+        currentParent = null;
+        flushFolded();
+        fm[key] = stripQuotes(val);
+        // store raw for description length? raw stripped is fine
+    }
+    flushFolded();
+    // --- validation rules ---
+    // name
+    const name = fm["name"];
+    if (name === undefined || (typeof name === "string" && name.trim() === "")) {
+        errors.push("name: missing");
+    }
+    else if (typeof name !== "string") {
+        errors.push("name: must be a string");
+    }
+    else {
+        const n = name.trim();
+        if (n.length < 1 || n.length > MAX_NAME_LEN) {
+            errors.push(`name: length must be 1-${MAX_NAME_LEN} (got ${n.length})`);
+        }
+        if (!NAME_RE.test(n)) {
+            errors.push(`name: invalid format '${n}' (must match ^[a-z0-9]([a-z0-9-]*[a-z0-9])?$)`);
+        }
+        if (n.includes("--")) {
+            errors.push("name: must not contain '--'");
+        }
+        if (dirname !== undefined && n !== dirname) {
+            errors.push(`name: must equal directory name '${dirname}' (got '${n}')`);
+        }
+    }
+    // description
+    const desc = fm["description"];
+    if (desc === undefined || (typeof desc === "string" && desc.trim() === "")) {
+        errors.push("description: missing or empty");
+    }
+    else if (typeof desc !== "string") {
+        errors.push("description: must be a string");
+    }
+    else {
+        const d = desc.trim();
+        if (d.length < MIN_DESC || d.length > MAX_DESC) {
+            errors.push(`description: length must be 1-${MAX_DESC} (got ${d.length})`);
+        }
+    }
+    // metadata values all strings - check raw entries for non-string literals
+    if (fm["metadata"] !== undefined) {
+        const meta = fm["metadata"];
+        const rawMap = fm.__metaRaw ?? {};
+        if (typeof meta !== "object" || meta === null || Array.isArray(meta)) {
+            errors.push("metadata: must be a map of strings");
+        }
+        else {
+            for (const [k, v] of Object.entries(meta)) {
+                if (typeof v !== "string") {
+                    errors.push(`metadata: value for '${k}' must be a string`);
+                }
+                else {
+                    const raw = rawMap[k] ?? v;
+                    // raw is the stored trimmed value without quotes as appears after colon
+                    // If raw is numeric / boolean / null without quotes, treat as non-string
+                    if (/^-?\d+(\.\d+)?$/.test(raw) || raw === "true" || raw === "false" || raw === "null") {
+                        errors.push(`metadata: value for '${k}' must be a string (got '${raw}')`);
+                    }
+                }
+            }
+        }
+    }
+    // body present
+    if (bodyTrimmed === "") {
+        errors.push("body: missing");
+    }
+    else {
+        const bodyLineCount = bodyTrimmed.split("\n").length;
+        if (bodyLineCount > MAX_BODY_LINES) {
+            warnings.push(`body: exceeds ${MAX_BODY_LINES} lines (got ${bodyLineCount})`);
+        }
+    }
+    const ok = errors.length === 0;
+    return { ok, errors, warnings };
+}
+function stripQuotes(s) {
+    const t = s.trim();
+    if ((t.startsWith('"') && t.endsWith('"')) || (t.startsWith("'") && t.endsWith("'"))) {
+        return t.slice(1, -1);
+    }
+    return t;
+}
+// helper for file-based validation (reads file and passes dirname)
+export function validateSkillFile(filePath, content) {
+    const parts = filePath.replace(/\\/g, "/").split("/");
+    // dirname is parent dir name: .../<dirname>/SKILL.md
+    const dir = parts.length >= 2 ? parts[parts.length - 2] : "";
+    return validateSkill(content, dir);
+}

package/dist/sources/ClaudeMemorySource.d.ts

@@ -0,0 +1,10 @@
+import type { MemorySource, SourceEntry } from "./MemorySource.js";
+export declare class ClaudeMemorySource implements MemorySource {
+    private enabledFlag;
+    private root;
+    name: string;
+    precedence: number;
+    constructor(enabledFlag: () => boolean, root?: string);
+    enabled(): boolean;
+    fetch(): Promise<SourceEntry[]>;
+}