@sweny-ai/core 0.1.28 → 0.1.30

package/dist/__tests__/skills-index.test.js

@@ -65,11 +65,11 @@ describe("skills registry", () => {
             expect(validCategories).toContain(skill.category);
         }
     });
-    it("isSkillConfigured checks env vars", () => {
+    it("isSkillConfigured checks required env vars", () => {
         expect(isSkillConfigured(github, { GITHUB_TOKEN: "ghp_xxx" })).toBe(true);
-        expect(isSkillConfigured(github, {})).toBe(false);
-        // Slack has all-optional config — needs at least one to be usable
-        expect(isSkillConfigured(slack, {})).toBe(false);
+        expect(isSkillConfigured(github, {})).toBe(false); // GITHUB_TOKEN is required
+        // Slack has all-optional config — always configured, tools validate at call time
+        expect(isSkillConfigured(slack, {})).toBe(true);
         expect(isSkillConfigured(slack, { SLACK_WEBHOOK_URL: "https://hooks.slack.com/..." })).toBe(true);
         expect(isSkillConfigured(slack, { SLACK_BOT_TOKEN: "xoxb-..." })).toBe(true);
     });

package/dist/__tests__/skills.test.js

@@ -1,10 +1,14 @@
 import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
+import { mkdtempSync, mkdirSync, writeFileSync, rmSync } from "node:fs";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
 import { github } from "../skills/github.js";
 import { linear } from "../skills/linear.js";
 import { slack } from "../skills/slack.js";
 import { sentry } from "../skills/sentry.js";
 import { datadog } from "../skills/datadog.js";
 import { notification } from "../skills/notification.js";
+import { loadCustomSkills, configuredSkills, createSkillMap } from "../skills/index.js";
 // ─── Helpers ─────────────────────────────────────────────────────
 const mockCtx = (config = {}) => ({
     config,
@@ -294,3 +298,119 @@ describe("notification skill", () => {
         expect(fetchMock.mock.calls[0][1].signal).toBeDefined();
     });
 });
+// ─── Custom skill discovery tests ──────────────────────────────
+describe("loadCustomSkills", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = mkdtempSync(join(tmpdir(), "sweny-skills-test-"));
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function writeSkill(dirName, content) {
+        const dir = join(tmpDir, ".claude", "skills", dirName);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "SKILL.md"), content);
+    }
+    it("returns empty array when .claude/skills/ does not exist", () => {
+        const skills = loadCustomSkills(tmpDir);
+        expect(skills).toEqual([]);
+    });
+    it("returns empty array when .claude/skills/ is empty", () => {
+        mkdirSync(join(tmpDir, ".claude", "skills"), { recursive: true });
+        const skills = loadCustomSkills(tmpDir);
+        expect(skills).toEqual([]);
+    });
+    it("discovers a valid custom skill from SKILL.md frontmatter", () => {
+        writeSkill("my-skill", `---
+name: my-skill
+description: A test skill
+---
+
+Instructions for Claude go here.
+`);
+        const skills = loadCustomSkills(tmpDir);
+        expect(skills).toHaveLength(1);
+        expect(skills[0]).toMatchObject({
+            id: "my-skill",
+            name: "my-skill",
+            description: "A test skill",
+            category: "general",
+        });
+        expect(skills[0].tools).toEqual([]);
+        expect(skills[0].config).toEqual({});
+    });
+    it("discovers multiple skills", () => {
+        writeSkill("skill-a", `---\nname: skill-a\ndescription: First\n---\nBody`);
+        writeSkill("skill-b", `---\nname: skill-b\ndescription: Second\n---\nBody`);
+        const skills = loadCustomSkills(tmpDir);
+        expect(skills).toHaveLength(2);
+        const ids = skills.map((s) => s.id).sort();
+        expect(ids).toEqual(["skill-a", "skill-b"]);
+    });
+    it("skips directories without SKILL.md", () => {
+        mkdirSync(join(tmpDir, ".claude", "skills", "no-skill-file"), { recursive: true });
+        writeFileSync(join(tmpDir, ".claude", "skills", "no-skill-file", "README.md"), "not a skill");
+        const skills = loadCustomSkills(tmpDir);
+        expect(skills).toEqual([]);
+    });
+    it("skips SKILL.md without frontmatter", () => {
+        writeSkill("no-frontmatter", "Just plain text, no YAML frontmatter.");
+        const skills = loadCustomSkills(tmpDir);
+        expect(skills).toEqual([]);
+    });
+    it("skips SKILL.md with frontmatter missing name field", () => {
+        writeSkill("no-name", `---\ndescription: Missing name\n---\nBody`);
+        const skills = loadCustomSkills(tmpDir);
+        expect(skills).toEqual([]);
+    });
+    it("uses fallback description when description is missing", () => {
+        writeSkill("name-only", `---\nname: name-only\n---\nBody`);
+        const skills = loadCustomSkills(tmpDir);
+        expect(skills).toHaveLength(1);
+        expect(skills[0].description).toBe("Custom skill: name-only");
+    });
+    it("skips malformed YAML in frontmatter", () => {
+        writeSkill("bad-yaml", `---\n: [invalid yaml\n---\nBody`);
+        const skills = loadCustomSkills(tmpDir);
+        expect(skills).toEqual([]);
+    });
+});
+describe("configuredSkills with custom skills", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = mkdtempSync(join(tmpdir(), "sweny-configured-test-"));
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    function writeSkill(dirName, content) {
+        const dir = join(tmpDir, ".claude", "skills", dirName);
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "SKILL.md"), content);
+    }
+    it("includes custom skills alongside configured built-ins", () => {
+        writeSkill("my-custom", `---\nname: my-custom\ndescription: Custom\n---\nBody`);
+        const skills = configuredSkills({}, tmpDir);
+        const ids = skills.map((s) => s.id);
+        expect(ids).toContain("my-custom");
+        // Skills with only optional config are always configured
+        expect(ids).toContain("notification");
+        expect(ids).toContain("slack");
+    });
+    it("built-in skills take precedence over custom skills with same ID", () => {
+        writeSkill("notification", `---\nname: notification\ndescription: Custom override attempt\n---\nBody`);
+        const skills = configuredSkills({}, tmpDir);
+        const notif = skills.filter((s) => s.id === "notification");
+        expect(notif).toHaveLength(1);
+        // Should be the built-in (has tools), not the custom one (tools: [])
+        expect(notif[0].tools.length).toBeGreaterThan(0);
+    });
+    it("custom skills are usable in createSkillMap", () => {
+        writeSkill("extract-colors", `---\nname: extract-colors\ndescription: Route color extraction\n---\nBody`);
+        const skills = configuredSkills({}, tmpDir);
+        const map = createSkillMap(skills);
+        expect(map.has("extract-colors")).toBe(true);
+        expect(map.get("extract-colors").tools).toEqual([]);
+    });
+});

package/dist/cli/main.js

@@ -194,7 +194,7 @@ triageCmd.action(async (options) => {
         console.log(formatBanner(config, version));
     }
     // ── Build skill map + MCP servers + Claude client ──────────
-    const skills = createSkillMap(configuredSkills());
+    const skills = createSkillMap(configuredSkills(process.env, process.cwd()));
     const mcpAutoConfig = buildMcpAutoConfig(config);
     const mcpServers = buildAutoMcpServers(mcpAutoConfig);
     const claude = new ClaudeClient({
@@ -412,7 +412,7 @@ implementCmd.action(async (issueId, options) => {
             fileConfig["output-dir"] ||
             ".sweny/output",
     };
-    const skills = createSkillMap(configuredSkills());
+    const skills = createSkillMap(configuredSkills(process.env, process.cwd()));
     const mcpAutoConfig = buildMcpAutoConfig(config);
     const mcpServers = buildAutoMcpServers(mcpAutoConfig);
     const claude = new ClaudeClient({
@@ -546,7 +546,7 @@ export async function workflowRunAction(file, options) {
     const config = parseCliInputs(options, fileConfig);
     const isJson = Boolean(options.json);
     const isTTY = !isJson && (process.stderr.isTTY ?? false);
-    const skills = createSkillMap(configuredSkills());
+    const skills = createSkillMap(configuredSkills(process.env, process.cwd()));
     const mcpAutoConfig = buildMcpAutoConfig(config);
     const mcpServers = buildAutoMcpServers(mcpAutoConfig);
     const claude = new ClaudeClient({

package/dist/skills/index.d.ts

@@ -14,6 +14,15 @@ import { notification } from "./notification.js";
 import { supabase } from "./supabase.js";
 export declare const builtinSkills: Skill[];
 export { github, linear, slack, sentry, datadog, betterstack, notification, supabase };
+/**
+ * Load custom skills from a `.claude/skills/` directory.
+ *
+ * Custom skills are instruction-only (no tools or config) — they provide
+ * guidance documents that the coding agent reads from the filesystem.
+ * Registering them here ensures workflow validation recognises the skill IDs
+ * so nodes referencing them don't produce spurious warnings.
+ */
+export declare function loadCustomSkills(cwd?: string): Skill[];
 /**
  * Build a skill map from an array of skills.
  * Pass to `execute()` as the `skills` option.
@@ -32,16 +41,16 @@ export declare function allSkills(): Map<string, Skill>;
 /**
  * Check if a skill is usable given the available environment.
  *
- * - All required config fields must have values.
- * - If a skill has env-backed config fields (even optional ones),
- *   at least one must be set — otherwise the skill has zero credentials.
- * - Skills with no env-backed config are always considered configured.
+ * A skill is configured when all its *required* config fields are set.
+ * Optional fields are validated by individual tool handlers at call time,
+ * so missing optional config never disqualifies the skill.
  */
 export declare function isSkillConfigured(skill: Skill, env?: Record<string, string | undefined>): boolean;
 /**
- * From all builtins, return only the skills that have their required env vars set.
+ * From all builtins + custom repo skills, return only the skills that are usable.
+ * Built-in skills are filtered by env vars; custom skills are always included.
  */
-export declare function configuredSkills(env?: Record<string, string | undefined>): Skill[];
+export declare function configuredSkills(env?: Record<string, string | undefined>, cwd?: string): Skill[];
 /**
  * Validate that a workflow's skill requirements are satisfiable.
  *

package/dist/skills/index.js

@@ -3,6 +3,9 @@
  *
  * All built-in skills + helpers to build a skill map from config.
  */
+import { readdirSync, readFileSync, existsSync } from "node:fs";
+import { join } from "node:path";
+import YAML from "yaml";
 import { github } from "./github.js";
 import { linear } from "./linear.js";
 import { slack } from "./slack.js";
@@ -14,6 +17,65 @@ import { supabase } from "./supabase.js";
 // ─── Built-in skill catalog ─────────────────────────────────────
 export const builtinSkills = [github, linear, slack, sentry, datadog, betterstack, notification, supabase];
 export { github, linear, slack, sentry, datadog, betterstack, notification, supabase };
+// ─── Custom skill discovery ─────────────────────────────────────
+/**
+ * Load custom skills from a `.claude/skills/` directory.
+ *
+ * Custom skills are instruction-only (no tools or config) — they provide
+ * guidance documents that the coding agent reads from the filesystem.
+ * Registering them here ensures workflow validation recognises the skill IDs
+ * so nodes referencing them don't produce spurious warnings.
+ */
+export function loadCustomSkills(cwd = process.cwd()) {
+    const skillsDir = join(cwd, ".claude", "skills");
+    if (!existsSync(skillsDir))
+        return [];
+    const skills = [];
+    let entries;
+    try {
+        entries = readdirSync(skillsDir, { withFileTypes: true })
+            .filter((d) => d.isDirectory())
+            .map((d) => d.name);
+    }
+    catch {
+        return [];
+    }
+    for (const dirName of entries) {
+        const skillFile = join(skillsDir, dirName, "SKILL.md");
+        if (!existsSync(skillFile))
+            continue;
+        try {
+            const content = readFileSync(skillFile, "utf-8");
+            const frontmatter = parseFrontmatter(content);
+            if (!frontmatter?.name)
+                continue;
+            skills.push({
+                id: frontmatter.name,
+                name: frontmatter.name,
+                description: frontmatter.description ?? `Custom skill: ${frontmatter.name}`,
+                category: "general",
+                config: {},
+                tools: [],
+            });
+        }
+        catch {
+            // Skip malformed skill files
+        }
+    }
+    return skills;
+}
+/** Extract YAML frontmatter from a markdown file (between --- delimiters). */
+function parseFrontmatter(content) {
+    const match = content.match(/^---\s*\n([\s\S]*?)\n---/);
+    if (!match)
+        return null;
+    try {
+        return YAML.parse(match[1]);
+    }
+    catch {
+        return null;
+    }
+}
 // ─── Registry helpers ───────────────────────────────────────────
 /**
  * Build a skill map from an array of skills.
@@ -44,28 +106,33 @@ export function allSkills() {
 /**
  * Check if a skill is usable given the available environment.
  *
- * - All required config fields must have values.
- * - If a skill has env-backed config fields (even optional ones),
- *   at least one must be set — otherwise the skill has zero credentials.
- * - Skills with no env-backed config are always considered configured.
+ * A skill is configured when all its *required* config fields are set.
+ * Optional fields are validated by individual tool handlers at call time,
+ * so missing optional config never disqualifies the skill.
  */
 export function isSkillConfigured(skill, env = process.env) {
-    const envFields = Object.values(skill.config).filter((f) => f.env);
-    if (envFields.length === 0)
-        return true; // no env needed
-    // All required fields must be set
-    for (const field of envFields) {
-        if (field.required && !env[field.env])
+    for (const field of Object.values(skill.config)) {
+        if (field.required && field.env && !env[field.env])
             return false;
     }
-    // At least one env-backed field must be set (handles all-optional skills like slack)
-    return envFields.some((f) => env[f.env]);
+    return true;
 }
 /**
- * From all builtins, return only the skills that have their required env vars set.
+ * From all builtins + custom repo skills, return only the skills that are usable.
+ * Built-in skills are filtered by env vars; custom skills are always included.
  */
-export function configuredSkills(env = process.env) {
-    return builtinSkills.filter((s) => isSkillConfigured(s, env));
+export function configuredSkills(env = process.env, cwd) {
+    const configured = builtinSkills.filter((s) => isSkillConfigured(s, env));
+    const custom = loadCustomSkills(cwd);
+    // Deduplicate: built-in skills take precedence over custom skills with the same ID
+    const ids = new Set(configured.map((s) => s.id));
+    for (const skill of custom) {
+        if (!ids.has(skill.id)) {
+            configured.push(skill);
+            ids.add(skill.id);
+        }
+    }
+    return configured;
 }
 export function validateWorkflowSkills(workflow, available) {
     const configured = [];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@sweny-ai/core",
-  "version": "0.1.28",
+  "version": "0.1.30",
   "type": "module",
   "bin": {
     "sweny": "./dist/cli/main.js"