@oxecli/oxe 1.0.0

package/dist/skills.js

@@ -0,0 +1,141 @@
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { SKILLS_DIR } from "./config.js";
+const FRONTMATTER_RE = /^---[ \t]*\r?\n(.*?)\r?\n---[ \t]*\r?\n?([\s\S]*)$/;
+function naturalSortKey(s) {
+    return s.replace(/\d+/g, (m) => m.padStart(12, "0")).toLowerCase();
+}
+export function parseSkillFrontmatter(text) {
+    const match = FRONTMATTER_RE.exec(text);
+    if (!match)
+        return [{}, text];
+    let parsed;
+    try {
+        parsed = YAML.parse(match[1]);
+    }
+    catch {
+        return [{}, text];
+    }
+    if (!parsed || typeof parsed !== "object" || Array.isArray(parsed))
+        return [{}, text];
+    const p = parsed;
+    const name = String(p["name"] ?? "").trim();
+    const description = String(p["description"] ?? "").trim();
+    return [{ name, description }, match[2]];
+}
+function scanSkills() {
+    const skills = [];
+    const seen = new Set();
+    if (!fs.existsSync(SKILLS_DIR) || !fs.statSync(SKILLS_DIR).isDirectory())
+        return skills;
+    const subs = fs
+        .readdirSync(SKILLS_DIR, { withFileTypes: true })
+        .filter((d) => d.isDirectory())
+        .sort((a, b) => naturalSortKey(a.name).localeCompare(naturalSortKey(b.name)));
+    for (const sub of subs) {
+        const mdPath = path.join(SKILLS_DIR, sub.name, "SKILL.md");
+        if (!fs.existsSync(mdPath))
+            continue;
+        let text;
+        try {
+            text = fs.readFileSync(mdPath, "utf-8");
+        }
+        catch {
+            continue;
+        }
+        const [meta] = parseSkillFrontmatter(text);
+        const name = meta["name"];
+        if (!name)
+            continue;
+        if (seen.has(name))
+            continue;
+        seen.add(name);
+        skills.push({ name, description: meta["description"] ?? "", path: mdPath, dir: sub.name });
+    }
+    return skills;
+}
+let availableSkills = null;
+export function getSkills() {
+    if (availableSkills === null)
+        availableSkills = scanSkills();
+    return availableSkills;
+}
+export function refreshSkills() {
+    availableSkills = scanSkills();
+}
+function listSkillAssets(skillDir) {
+    const scripts = [];
+    const references = [];
+    for (const [folder, bucket] of [
+        ["scripts", scripts],
+        ["references", references],
+    ]) {
+        const base = path.join(skillDir, folder);
+        if (!fs.existsSync(base))
+            continue;
+        const walk = (dir) => {
+            for (const entry of fs.readdirSync(dir, { withFileTypes: true })) {
+                const full = path.join(dir, entry.name);
+                if (entry.isDirectory()) {
+                    walk(full);
+                }
+                else if (entry.isFile()) {
+                    const fname = entry.name;
+                    if (fname.startsWith(".") ||
+                        fname.startsWith("~") ||
+                        /\.(tmp|swp|bak)$/.test(fname)) {
+                        continue;
+                    }
+                    bucket.push(path.resolve(full));
+                }
+            }
+        };
+        walk(base);
+        bucket.sort((a, b) => naturalSortKey(a).localeCompare(naturalSortKey(b)));
+    }
+    return { scripts, references };
+}
+export function toolListSkills() {
+    const skills = getSkills();
+    if (!skills.length)
+        return "No skills available.";
+    const lines = ["Available skills:"];
+    for (const skill of skills) {
+        lines.push(skill.description ? `- ${skill.name}: ${skill.description}` : `- ${skill.name}`);
+    }
+    return lines.join("\n");
+}
+export function toolLoadSkill(skillName) {
+    if (typeof skillName !== "string" || !skillName.trim()) {
+        return "Error: skill_name must be a non-empty string.";
+    }
+    const skills = getSkills();
+    const skill = skills.find((s) => s.name === skillName);
+    if (!skill) {
+        const available = skills.map((s) => s.name).join(", ") || "none";
+        return `Error: unknown skill '${skillName}'. Available skills: ${available}`;
+    }
+    let text;
+    try {
+        text = fs.readFileSync(skill.path, "utf-8");
+    }
+    catch (err) {
+        return `Error: could not read skill '${skillName}': ${err}`;
+    }
+    const [, body] = parseSkillFrontmatter(text);
+    const assets = listSkillAssets(skill.dir);
+    const lines = [body.replace(/\s+$/, "")];
+    if (assets.scripts.length) {
+        lines.push("\nScripts available in this skill (run via bash as needed):");
+        lines.push(...assets.scripts.map((s) => `- ${s}`));
+    }
+    if (assets.references.length) {
+        lines.push("\nReference files available in this skill (read via read_file as needed):");
+        lines.push(...assets.references.map((r) => `- ${r}`));
+    }
+    if (!assets.scripts.length && !assets.references.length) {
+        lines.push("\nThis skill has no scripts/ or references/ subfolders.");
+    }
+    return lines.join("\n");
+}

package/dist/system.js

@@ -0,0 +1,19 @@
+import { osPrefix, SYSTEM_PROMPT_BODY } from "./config.js";
+import { getSkills } from "./skills.js";
+function buildSystemPrompt() {
+    const skills = getSkills();
+    let skillsText = "";
+    if (skills.length) {
+        const lines = [
+            "Available skills (call load_skill(name) to load the full SKILL.md for details):",
+        ];
+        for (const s of skills) {
+            lines.push(s.description ? `- ${s.name}: ${s.description}` : `- ${s.name}`);
+        }
+        lines.push("If a user task requires specialized domain knowledge matching an available skill, " +
+            "call load_skill(name) before proceeding.");
+        skillsText = "\n\n" + lines.join("\n") + "\n";
+    }
+    return osPrefix() + SYSTEM_PROMPT_BODY + skillsText;
+}
+export const SYSTEM_PROMPT = buildSystemPrompt();