@skilljack/mcp 0.6.0 → 0.7.1

package/dist/skill-config.js

@@ -0,0 +1,450 @@
+/**
+ * Configuration management for skill directories.
+ *
+ * Handles loading/saving skill directory configuration from:
+ * 1. CLI args (highest priority)
+ * 2. SKILLS_DIR environment variable
+ * 3. Config file (~/.skilljack/config.json)
+ *
+ * Supports both local directories and GitHub repository URLs.
+ */
+import * as fs from "node:fs";
+import * as path from "node:path";
+import * as os from "node:os";
+import { isGitHubUrl, parseGitHubUrl, isRepoAllowed, getGitHubConfig } from "./github-config.js";
+/**
+ * Check if a path is valid (exists for local, always valid for GitHub).
+ */
+function isValidPath(p) {
+    if (isGitHubUrl(p)) {
+        return true; // GitHub URLs are validated during sync
+    }
+    return fs.existsSync(p);
+}
+/**
+ * Get the source type for a path.
+ */
+function getSourceType(p) {
+    return isGitHubUrl(p) ? "github" : "local";
+}
+/**
+ * Check if a path is allowed (local paths are always allowed,
+ * GitHub URLs must have their org/user in the allowlist).
+ */
+function isPathAllowed(p) {
+    if (!isGitHubUrl(p)) {
+        return true; // Local paths are always allowed
+    }
+    try {
+        const spec = parseGitHubUrl(p);
+        const config = getGitHubConfig();
+        return isRepoAllowed(spec, config);
+    }
+    catch {
+        return false; // Invalid GitHub URL
+    }
+}
+/**
+ * Separator for multiple paths in SKILLS_DIR environment variable.
+ */
+const PATH_LIST_SEPARATOR = ",";
+/**
+ * Get the platform-appropriate config directory path.
+ * Returns ~/.skilljack on Unix, %USERPROFILE%\.skilljack on Windows.
+ */
+export function getConfigDir() {
+    return path.join(os.homedir(), ".skilljack");
+}
+/**
+ * Get the full path to the config file.
+ */
+export function getConfigPath() {
+    return path.join(getConfigDir(), "config.json");
+}
+/**
+ * Ensure the config directory exists.
+ */
+function ensureConfigDir() {
+    const configDir = getConfigDir();
+    if (!fs.existsSync(configDir)) {
+        fs.mkdirSync(configDir, { recursive: true });
+    }
+}
+/**
+ * Load config from the config file.
+ * Returns empty config if file doesn't exist.
+ */
+export function loadConfigFile() {
+    const configPath = getConfigPath();
+    if (!fs.existsSync(configPath)) {
+        return { skillDirectories: [], skillInvocationOverrides: {} };
+    }
+    try {
+        const content = fs.readFileSync(configPath, "utf-8");
+        const parsed = JSON.parse(content);
+        // Validate and normalize directories (handle both local paths and GitHub URLs)
+        const skillDirectories = Array.isArray(parsed.skillDirectories)
+            ? parsed.skillDirectories
+                .filter((p) => typeof p === "string")
+                .map((p) => isGitHubUrl(p) ? p : path.resolve(p))
+            : [];
+        // Validate and normalize invocation overrides
+        const skillInvocationOverrides = {};
+        if (parsed.skillInvocationOverrides && typeof parsed.skillInvocationOverrides === "object") {
+            for (const [name, override] of Object.entries(parsed.skillInvocationOverrides)) {
+                if (typeof override === "object" && override !== null) {
+                    const validOverride = {};
+                    const o = override;
+                    if (typeof o.assistant === "boolean")
+                        validOverride.assistant = o.assistant;
+                    if (typeof o.user === "boolean")
+                        validOverride.user = o.user;
+                    if (Object.keys(validOverride).length > 0) {
+                        skillInvocationOverrides[name] = validOverride;
+                    }
+                }
+            }
+        }
+        return {
+            skillDirectories,
+            skillInvocationOverrides,
+            staticMode: parsed.staticMode === true,
+            githubAllowedOrgs: Array.isArray(parsed.githubAllowedOrgs) ? parsed.githubAllowedOrgs : [],
+            githubAllowedUsers: Array.isArray(parsed.githubAllowedUsers) ? parsed.githubAllowedUsers : [],
+        };
+    }
+    catch (error) {
+        console.error(`Warning: Failed to parse config file: ${error}`);
+        return { skillDirectories: [], skillInvocationOverrides: {} };
+    }
+}
+/**
+ * Save config to the config file.
+ */
+export function saveConfigFile(config) {
+    ensureConfigDir();
+    const configPath = getConfigPath();
+    try {
+        fs.writeFileSync(configPath, JSON.stringify(config, null, 2), "utf-8");
+    }
+    catch (error) {
+        throw new Error(`Failed to save config file: ${error}`);
+    }
+}
+/**
+ * Parse CLI arguments for skill directories.
+ * Returns resolved absolute paths for local dirs, unchanged for GitHub URLs.
+ */
+export function parseCLIArgs() {
+    const dirs = [];
+    const args = process.argv.slice(2);
+    for (const arg of args) {
+        if (!arg.startsWith("-")) {
+            const paths = arg
+                .split(PATH_LIST_SEPARATOR)
+                .map((p) => p.trim())
+                .filter((p) => p.length > 0)
+                .map((p) => isGitHubUrl(p) ? p : path.resolve(p));
+            dirs.push(...paths);
+        }
+    }
+    return [...new Set(dirs)]; // Deduplicate
+}
+/**
+ * Parse SKILLS_DIR environment variable.
+ * Returns resolved absolute paths for local dirs, unchanged for GitHub URLs.
+ */
+export function parseEnvVar() {
+    const envDir = process.env.SKILLS_DIR;
+    if (!envDir) {
+        return [];
+    }
+    const dirs = envDir
+        .split(PATH_LIST_SEPARATOR)
+        .map((p) => p.trim())
+        .filter((p) => p.length > 0)
+        .map((p) => isGitHubUrl(p) ? p : path.resolve(p));
+    return [...new Set(dirs)]; // Deduplicate
+}
+/**
+ * Get all skill directories with their source information.
+ * Priority: CLI args > env var > config file
+ */
+export function getConfigState() {
+    // Check CLI args first
+    const cliDirs = parseCLIArgs();
+    if (cliDirs.length > 0) {
+        return {
+            directories: cliDirs.map((p) => ({
+                path: p,
+                source: "cli",
+                type: getSourceType(p),
+                skillCount: 0, // Will be filled in by caller
+                valid: isValidPath(p),
+                allowed: isPathAllowed(p),
+            })),
+            activeSource: "cli",
+            isOverridden: true,
+        };
+    }
+    // Check env var next
+    const envDirs = parseEnvVar();
+    if (envDirs.length > 0) {
+        return {
+            directories: envDirs.map((p) => ({
+                path: p,
+                source: "env",
+                type: getSourceType(p),
+                skillCount: 0,
+                valid: isValidPath(p),
+                allowed: isPathAllowed(p),
+            })),
+            activeSource: "env",
+            isOverridden: true,
+        };
+    }
+    // Fall back to config file
+    const config = loadConfigFile();
+    return {
+        directories: config.skillDirectories.map((p) => ({
+            path: p,
+            source: "config",
+            type: getSourceType(p),
+            skillCount: 0,
+            valid: isValidPath(p),
+            allowed: isPathAllowed(p),
+        })),
+        activeSource: "config",
+        isOverridden: false,
+    };
+}
+/**
+ * Get skill directories from all sources combined.
+ * Used for the UI to show all configured directories.
+ */
+export function getAllDirectoriesWithSources() {
+    const all = [];
+    const seen = new Set();
+    // CLI dirs
+    for (const p of parseCLIArgs()) {
+        if (!seen.has(p)) {
+            seen.add(p);
+            all.push({
+                path: p,
+                source: "cli",
+                type: getSourceType(p),
+                skillCount: 0,
+                valid: isValidPath(p),
+                allowed: isPathAllowed(p),
+            });
+        }
+    }
+    // Env dirs
+    for (const p of parseEnvVar()) {
+        if (!seen.has(p)) {
+            seen.add(p);
+            all.push({
+                path: p,
+                source: "env",
+                type: getSourceType(p),
+                skillCount: 0,
+                valid: isValidPath(p),
+                allowed: isPathAllowed(p),
+            });
+        }
+    }
+    // Config file dirs
+    const config = loadConfigFile();
+    for (const p of config.skillDirectories) {
+        if (!seen.has(p)) {
+            seen.add(p);
+            all.push({
+                path: p,
+                source: "config",
+                type: getSourceType(p),
+                skillCount: 0,
+                valid: isValidPath(p),
+                allowed: isPathAllowed(p),
+            });
+        }
+    }
+    return all;
+}
+/**
+ * Add a directory or GitHub URL to the config file.
+ * Does not affect CLI or env var configurations.
+ */
+export function addDirectoryToConfig(directory) {
+    // For GitHub URLs, store as-is; for local paths, resolve to absolute
+    const normalized = isGitHubUrl(directory) ? directory : path.resolve(directory);
+    // Validate local directories exist
+    if (!isGitHubUrl(directory)) {
+        if (!fs.existsSync(normalized)) {
+            throw new Error(`Directory does not exist: ${normalized}`);
+        }
+        if (!fs.statSync(normalized).isDirectory()) {
+            throw new Error(`Path is not a directory: ${normalized}`);
+        }
+    }
+    const config = loadConfigFile();
+    // Check for duplicate
+    if (config.skillDirectories.includes(normalized)) {
+        throw new Error(`Already configured: ${normalized}`);
+    }
+    config.skillDirectories.push(normalized);
+    saveConfigFile(config);
+}
+/**
+ * Remove a directory or GitHub URL from the config file.
+ * Only removes from config file, not CLI or env var.
+ */
+export function removeDirectoryFromConfig(directory) {
+    // For GitHub URLs, use as-is; for local paths, resolve to absolute
+    const normalized = isGitHubUrl(directory) ? directory : path.resolve(directory);
+    const config = loadConfigFile();
+    const index = config.skillDirectories.indexOf(normalized);
+    if (index === -1) {
+        throw new Error(`Not found in config: ${normalized}`);
+    }
+    config.skillDirectories.splice(index, 1);
+    saveConfigFile(config);
+}
+/**
+ * Get only the active skill directories (respecting priority).
+ * This is what the server should use for skill discovery.
+ */
+export function getActiveDirectories() {
+    const state = getConfigState();
+    return state.directories.map((d) => d.path);
+}
+/**
+ * Get static mode setting from config file.
+ */
+export function getStaticModeFromConfig() {
+    const config = loadConfigFile();
+    return config.staticMode === true;
+}
+/**
+ * Set static mode setting in config file.
+ */
+export function setStaticModeInConfig(enabled) {
+    const config = loadConfigFile();
+    config.staticMode = enabled;
+    saveConfigFile(config);
+}
+/**
+ * Get all skill invocation overrides from the config file.
+ */
+export function getSkillInvocationOverrides() {
+    const config = loadConfigFile();
+    return config.skillInvocationOverrides || {};
+}
+/**
+ * Set an invocation override for a skill.
+ * @param skillName - The name of the skill
+ * @param setting - Which setting to override ("assistant" or "user")
+ * @param value - The new value for the setting
+ */
+export function setSkillInvocationOverride(skillName, setting, value) {
+    const config = loadConfigFile();
+    if (!config.skillInvocationOverrides) {
+        config.skillInvocationOverrides = {};
+    }
+    if (!config.skillInvocationOverrides[skillName]) {
+        config.skillInvocationOverrides[skillName] = {};
+    }
+    config.skillInvocationOverrides[skillName][setting] = value;
+    saveConfigFile(config);
+}
+/**
+ * Clear an invocation override for a skill (revert to frontmatter default).
+ * @param skillName - The name of the skill
+ * @param setting - Which setting to clear (omit to clear both)
+ */
+export function clearSkillInvocationOverride(skillName, setting) {
+    const config = loadConfigFile();
+    if (!config.skillInvocationOverrides || !config.skillInvocationOverrides[skillName]) {
+        return; // Nothing to clear
+    }
+    if (setting) {
+        delete config.skillInvocationOverrides[skillName][setting];
+        // Clean up empty override objects
+        if (Object.keys(config.skillInvocationOverrides[skillName]).length === 0) {
+            delete config.skillInvocationOverrides[skillName];
+        }
+    }
+    else {
+        delete config.skillInvocationOverrides[skillName];
+    }
+    saveConfigFile(config);
+}
+/**
+ * Get the GitHub allowed orgs from config file.
+ */
+export function getGitHubAllowedOrgs() {
+    const config = loadConfigFile();
+    return config.githubAllowedOrgs || [];
+}
+/**
+ * Get the GitHub allowed users from config file.
+ */
+export function getGitHubAllowedUsers() {
+    const config = loadConfigFile();
+    return config.githubAllowedUsers || [];
+}
+/**
+ * Add a GitHub org to the allowed list.
+ * @param org - The org name to allow
+ */
+export function addGitHubAllowedOrg(org) {
+    const config = loadConfigFile();
+    if (!config.githubAllowedOrgs) {
+        config.githubAllowedOrgs = [];
+    }
+    const normalized = org.toLowerCase().trim();
+    if (!config.githubAllowedOrgs.some((o) => o.toLowerCase() === normalized)) {
+        config.githubAllowedOrgs.push(org.trim());
+        saveConfigFile(config);
+    }
+}
+/**
+ * Remove a GitHub org from the allowed list.
+ * @param org - The org name to remove
+ */
+export function removeGitHubAllowedOrg(org) {
+    const config = loadConfigFile();
+    if (!config.githubAllowedOrgs) {
+        return;
+    }
+    const normalized = org.toLowerCase().trim();
+    config.githubAllowedOrgs = config.githubAllowedOrgs.filter((o) => o.toLowerCase() !== normalized);
+    saveConfigFile(config);
+}
+/**
+ * Add a GitHub user to the allowed list.
+ * @param user - The user name to allow
+ */
+export function addGitHubAllowedUser(user) {
+    const config = loadConfigFile();
+    if (!config.githubAllowedUsers) {
+        config.githubAllowedUsers = [];
+    }
+    const normalized = user.toLowerCase().trim();
+    if (!config.githubAllowedUsers.some((u) => u.toLowerCase() === normalized)) {
+        config.githubAllowedUsers.push(user.trim());
+        saveConfigFile(config);
+    }
+}
+/**
+ * Remove a GitHub user from the allowed list.
+ * @param user - The user name to remove
+ */
+export function removeGitHubAllowedUser(user) {
+    const config = loadConfigFile();
+    if (!config.githubAllowedUsers) {
+        return;
+    }
+    const normalized = user.toLowerCase().trim();
+    config.githubAllowedUsers = config.githubAllowedUsers.filter((u) => u.toLowerCase() !== normalized);
+    saveConfigFile(config);
+}

package/dist/skill-discovery.d.ts

@@ -4,6 +4,24 @@
  * Discovers Agent Skills from a directory, parses YAML frontmatter,
  * and generates server instructions XML.
  */
+/**
+ * Source information for a skill.
+ * Indicates whether the skill comes from a local directory or GitHub repository.
+ */
+export interface SkillSource {
+    type: "local" | "github" | "bundled";
+    displayName: string;
+    owner?: string;
+    repo?: string;
+}
+/**
+ * Default source for skills discovered without explicit source info.
+ */
+export declare const DEFAULT_SKILL_SOURCE: SkillSource;
+/**
+ * Source for skills bundled with the server package.
+ */
+export declare const BUNDLED_SKILL_SOURCE: SkillSource;
 /**
  * Metadata extracted from a skill's SKILL.md frontmatter.
  */
@@ -11,12 +29,22 @@ export interface SkillMetadata {
     name: string;
     description: string;
     path: string;
+    disableModelInvocation?: boolean;
+    userInvocable?: boolean;
+    effectiveAssistantInvocable: boolean;
+    effectiveUserInvocable: boolean;
+    isAssistantOverridden: boolean;
+    isUserOverridden: boolean;
+    source: SkillSource;
 }
 /**
  * Discover all skills in a directory.
  * Scans for subdirectories containing SKILL.md files.
+ *
+ * @param skillsDir - The directory to scan for skills
+ * @param source - Optional source info to attach to discovered skills
  */
-export declare function discoverSkills(skillsDir: string): SkillMetadata[];
+export declare function discoverSkills(skillsDir: string, source?: SkillSource): SkillMetadata[];
 /**
  * Generate the server instructions with available skills.
  * Includes a brief preamble about skill usage following the Agent Skills spec.
@@ -31,3 +59,26 @@ export declare function loadSkillContent(skillPath: string): string;
  * Uses first-wins behavior: if duplicate names exist, the first occurrence is kept.
  */
 export declare function createSkillMap(skills: SkillMetadata[]): Map<string, SkillMetadata>;
+/**
+ * Invocation override settings per skill (imported type reference).
+ */
+interface SkillInvocationOverrides {
+    assistant?: boolean;
+    user?: boolean;
+}
+/**
+ * Apply invocation overrides from config to compute effective values.
+ * Returns a new array with updated effective* fields.
+ */
+export declare function applyInvocationOverrides(skills: SkillMetadata[], overrides: Record<string, SkillInvocationOverrides>): SkillMetadata[];
+/**
+ * Filter skills that can be invoked by the model (appear in tool description).
+ * Uses effective value which considers config overrides.
+ */
+export declare function getModelInvocableSkills(skills: SkillMetadata[]): SkillMetadata[];
+/**
+ * Filter skills that can be invoked by the user (appear in prompts menu).
+ * Uses effective value which considers config overrides.
+ */
+export declare function getUserInvocableSkills(skills: SkillMetadata[]): SkillMetadata[];
+export {};

package/dist/skill-discovery.js

@@ -7,6 +7,20 @@
 import * as fs from "node:fs";
 import * as path from "node:path";
 import { parse as parseYaml } from "yaml";
+/**
+ * Default source for skills discovered without explicit source info.
+ */
+export const DEFAULT_SKILL_SOURCE = {
+    type: "local",
+    displayName: "Local",
+};
+/**
+ * Source for skills bundled with the server package.
+ */
+export const BUNDLED_SKILL_SOURCE = {
+    type: "bundled",
+    displayName: "Bundled",
+};
 /**
  * Find the SKILL.md file in a skill directory.
  * Prefers SKILL.md (uppercase) but accepts skill.md (lowercase).
@@ -43,8 +57,11 @@ function parseFrontmatter(content) {
 /**
  * Discover all skills in a directory.
  * Scans for subdirectories containing SKILL.md files.
+ *
+ * @param skillsDir - The directory to scan for skills
+ * @param source - Optional source info to attach to discovered skills
  */
-export function discoverSkills(skillsDir) {
+export function discoverSkills(skillsDir, source) {
     const skills = [];
     if (!fs.existsSync(skillsDir)) {
         console.error(`Skills directory not found: ${skillsDir}`);
@@ -63,6 +80,8 @@ export function discoverSkills(skillsDir) {
             const { metadata } = parseFrontmatter(content);
             const name = metadata.name;
             const description = metadata.description;
+            const disableModelInvocation = metadata["disable-model-invocation"];
+            const userInvocable = metadata["user-invocable"];
             if (typeof name !== "string" || !name.trim()) {
                 console.error(`Skill at ${skillDir}: missing or invalid 'name' field`);
                 continue;
@@ -71,10 +90,21 @@ export function discoverSkills(skillsDir) {
                 console.error(`Skill at ${skillDir}: missing or invalid 'description' field`);
                 continue;
             }
+            const effectiveAssistant = disableModelInvocation !== true;
+            const effectiveUser = userInvocable !== false;
             skills.push({
                 name: name.trim(),
                 description: description.trim(),
                 path: skillMdPath,
+                disableModelInvocation: disableModelInvocation === true,
+                userInvocable: userInvocable !== false, // Default to true
+                // Initialize effective values from frontmatter (overrides applied later)
+                effectiveAssistantInvocable: effectiveAssistant,
+                effectiveUserInvocable: effectiveUser,
+                isAssistantOverridden: false,
+                isUserOverridden: false,
+                // Source info (local or GitHub)
+                source: source || DEFAULT_SKILL_SOURCE,
             });
         }
         catch (error) {
@@ -142,3 +172,42 @@ export function createSkillMap(skills) {
     }
     return map;
 }
+/**
+ * Apply invocation overrides from config to compute effective values.
+ * Returns a new array with updated effective* fields.
+ */
+export function applyInvocationOverrides(skills, overrides) {
+    return skills.map((skill) => {
+        const override = overrides[skill.name];
+        if (!override) {
+            return skill; // No override, keep frontmatter defaults
+        }
+        const hasAssistantOverride = override.assistant !== undefined;
+        const hasUserOverride = override.user !== undefined;
+        return {
+            ...skill,
+            effectiveAssistantInvocable: hasAssistantOverride
+                ? override.assistant
+                : !skill.disableModelInvocation,
+            effectiveUserInvocable: hasUserOverride
+                ? override.user
+                : skill.userInvocable !== false,
+            isAssistantOverridden: hasAssistantOverride,
+            isUserOverridden: hasUserOverride,
+        };
+    });
+}
+/**
+ * Filter skills that can be invoked by the model (appear in tool description).
+ * Uses effective value which considers config overrides.
+ */
+export function getModelInvocableSkills(skills) {
+    return skills.filter((skill) => skill.effectiveAssistantInvocable);
+}
+/**
+ * Filter skills that can be invoked by the user (appear in prompts menu).
+ * Uses effective value which considers config overrides.
+ */
+export function getUserInvocableSkills(skills) {
+    return skills.filter((skill) => skill.effectiveUserInvocable);
+}

package/dist/skill-display-tool.d.ts

@@ -0,0 +1,22 @@
+/**
+ * MCP App tool registration for skill display UI.
+ *
+ * Registers:
+ * - skill-display: Opens the skill display UI
+ * - skill-display-update-invocation: Updates invocation settings (UI-only)
+ * - skill-display-reset-override: Resets a skill to frontmatter defaults (UI-only)
+ */
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { SkillState } from "./skill-tool.js";
+/**
+ * Callback type for when invocation settings change.
+ */
+export type OnInvocationChangedCallback = () => void;
+/**
+ * Register skill-display MCP App tools and resource.
+ *
+ * @param server - The MCP server instance
+ * @param skillState - Shared skill state for getting skill info
+ * @param onInvocationChanged - Callback when invocation settings are changed
+ */
+export declare function registerSkillDisplayTool(server: McpServer, skillState: SkillState, onInvocationChanged: OnInvocationChangedCallback): void;