@skillkit/agents 1.5.0 → 1.6.1

package/dist/index.js

@@ -12,6 +12,7 @@ function createSkillXml(skill) {
 </skill>`;
 }
 function escapeXml(text) {
+  if (!text) return "";
   return text.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;").replace(/'/g, "&apos;");
 }
 
@@ -508,7 +509,8 @@ ${skillsXml}
   async isDetected() {
     const projectSkills = join8(process.cwd(), "skills");
     const globalClawdbot = join8(homedir7(), ".clawdbot");
-    return existsSync8(globalClawdbot) || existsSync8(projectSkills) && existsSync8(join8(process.cwd(), ".clawdbot"));
+    const clawdbotConfig = join8(process.cwd(), "clawdbot.json");
+    return existsSync8(projectSkills) || existsSync8(globalClawdbot) || existsSync8(clawdbotConfig);
   }
 };
 
@@ -1101,6 +1103,911 @@ ${skillsXml}
   }
 };
 
+// src/features/permissions.ts
+import { minimatch } from "minimatch";
+var PermissionManager = class {
+  config;
+  constructor(config) {
+    this.config = config || { default: "ask" };
+  }
+  /**
+   * Set permission configuration
+   */
+  setConfig(config) {
+    this.config = config;
+  }
+  /**
+   * Get permission configuration
+   */
+  getConfig() {
+    return this.config;
+  }
+  /**
+   * Check file access permission
+   */
+  checkFileAccess(path) {
+    return this.checkPattern(path, this.config.files);
+  }
+  /**
+   * Check command execution permission
+   */
+  checkCommandAccess(command) {
+    return this.checkPattern(command, this.config.commands);
+  }
+  /**
+   * Check network access permission
+   */
+  checkNetworkAccess(url) {
+    return this.checkPattern(url, this.config.network);
+  }
+  /**
+   * Check environment variable access
+   */
+  checkEnvAccess(varName) {
+    return this.checkPattern(varName, this.config.env);
+  }
+  /**
+   * Add file permission pattern
+   */
+  addFilePattern(pattern) {
+    if (!this.config.files) {
+      this.config.files = [];
+    }
+    this.config.files.push(pattern);
+  }
+  /**
+   * Add command permission pattern
+   */
+  addCommandPattern(pattern) {
+    if (!this.config.commands) {
+      this.config.commands = [];
+    }
+    this.config.commands.push(pattern);
+  }
+  /**
+   * Check pattern against permission list
+   */
+  checkPattern(value, patterns) {
+    if (!patterns || patterns.length === 0) {
+      return this.config.default || "ask";
+    }
+    for (const pattern of patterns) {
+      if (this.matchPattern(value, pattern.pattern)) {
+        return pattern.level;
+      }
+    }
+    return this.config.default || "ask";
+  }
+  /**
+   * Match value against pattern (glob-style)
+   *
+   * Uses minimatch for safe glob matching, avoiding ReDoS vulnerabilities.
+   */
+  matchPattern(value, pattern) {
+    return minimatch(value, pattern, { nocase: true });
+  }
+  /**
+   * Generate OpenCode-compatible permission config
+   */
+  generateOpenCodeConfig() {
+    const lines = [];
+    lines.push("# Permission Configuration");
+    lines.push("");
+    if (this.config.files && this.config.files.length > 0) {
+      lines.push("## File Access");
+      lines.push("");
+      for (const pattern of this.config.files) {
+        lines.push(`- ${pattern.level}: \`${pattern.pattern}\``);
+        if (pattern.reason) {
+          lines.push(`  - Reason: ${pattern.reason}`);
+        }
+      }
+      lines.push("");
+    }
+    if (this.config.commands && this.config.commands.length > 0) {
+      lines.push("## Command Execution");
+      lines.push("");
+      for (const pattern of this.config.commands) {
+        lines.push(`- ${pattern.level}: \`${pattern.pattern}\``);
+        if (pattern.reason) {
+          lines.push(`  - Reason: ${pattern.reason}`);
+        }
+      }
+      lines.push("");
+    }
+    if (this.config.network && this.config.network.length > 0) {
+      lines.push("## Network Access");
+      lines.push("");
+      for (const pattern of this.config.network) {
+        lines.push(`- ${pattern.level}: \`${pattern.pattern}\``);
+        if (pattern.reason) {
+          lines.push(`  - Reason: ${pattern.reason}`);
+        }
+      }
+      lines.push("");
+    }
+    lines.push(`Default: ${this.config.default || "ask"}`);
+    lines.push("");
+    return lines.join("\n");
+  }
+  /**
+   * Generate SKILL.md metadata for permissions
+   */
+  generateSkillMetadata() {
+    const metadata = {};
+    if (this.config.files) {
+      metadata.filePermissions = this.config.files.map((p) => ({
+        pattern: p.pattern,
+        level: p.level
+      }));
+    }
+    if (this.config.commands) {
+      metadata.commandPermissions = this.config.commands.map((p) => ({
+        pattern: p.pattern,
+        level: p.level
+      }));
+    }
+    if (this.config.network) {
+      metadata.networkPermissions = this.config.network.map((p) => ({
+        pattern: p.pattern,
+        level: p.level
+      }));
+    }
+    if (this.config.default) {
+      metadata.defaultPermission = this.config.default;
+    }
+    return metadata;
+  }
+  /**
+   * Parse permissions from SKILL.md metadata
+   */
+  static fromMetadata(metadata) {
+    const config = {};
+    if (metadata.filePermissions && Array.isArray(metadata.filePermissions)) {
+      config.files = metadata.filePermissions;
+    }
+    if (metadata.commandPermissions && Array.isArray(metadata.commandPermissions)) {
+      config.commands = metadata.commandPermissions;
+    }
+    if (metadata.networkPermissions && Array.isArray(metadata.networkPermissions)) {
+      config.network = metadata.networkPermissions;
+    }
+    if (metadata.defaultPermission) {
+      config.default = metadata.defaultPermission;
+    }
+    return config;
+  }
+  /**
+   * Merge two permission configs
+   */
+  static merge(base, override) {
+    return {
+      files: [...base.files || [], ...override.files || []],
+      commands: [...base.commands || [], ...override.commands || []],
+      network: [...base.network || [], ...override.network || []],
+      env: [...base.env || [], ...override.env || []],
+      default: override.default || base.default
+    };
+  }
+};
+function createPermissionManager(config) {
+  return new PermissionManager(config);
+}
+function isAllowed(level) {
+  return level === "allow";
+}
+function isDenied(level) {
+  return level === "deny";
+}
+function needsConfirmation(level) {
+  return level === "ask";
+}
+
+// src/features/globs.ts
+import { minimatch as minimatch2 } from "minimatch";
+var GlobMatcher = class {
+  config;
+  includePatterns;
+  excludePatterns;
+  constructor(config) {
+    this.config = config;
+    this.includePatterns = config.include.map((p) => this.patternToRegex(p));
+    this.excludePatterns = (config.exclude || []).map((p) => this.patternToRegex(p));
+  }
+  /**
+   * Check if a file matches the glob patterns
+   */
+  matches(filePath) {
+    const normalizedPath = filePath.replace(/\\/g, "/");
+    if (!this.config.matchHidden && this.isHiddenFile(normalizedPath)) {
+      return false;
+    }
+    for (const pattern of this.excludePatterns) {
+      if (pattern.test(normalizedPath)) {
+        return false;
+      }
+    }
+    for (const pattern of this.includePatterns) {
+      if (pattern.test(normalizedPath)) {
+        return true;
+      }
+    }
+    return false;
+  }
+  /**
+   * Filter a list of files
+   */
+  filter(filePaths) {
+    return filePaths.filter((p) => this.matches(p));
+  }
+  /**
+   * Get all include patterns
+   */
+  getIncludePatterns() {
+    return [...this.config.include];
+  }
+  /**
+   * Get all exclude patterns
+   */
+  getExcludePatterns() {
+    return [...this.config.exclude || []];
+  }
+  /**
+   * Add an include pattern
+   */
+  addInclude(pattern) {
+    this.config.include.push(pattern);
+    this.includePatterns.push(this.patternToRegex(pattern));
+  }
+  /**
+   * Add an exclude pattern
+   */
+  addExclude(pattern) {
+    if (!this.config.exclude) {
+      this.config.exclude = [];
+    }
+    this.config.exclude.push(pattern);
+    this.excludePatterns.push(this.patternToRegex(pattern));
+  }
+  /**
+   * Convert glob pattern to regex using minimatch
+   *
+   * Uses the battle-tested minimatch library to avoid ReDoS vulnerabilities
+   * and ensure consistent glob matching behavior.
+   */
+  patternToRegex(pattern) {
+    const isNegated = pattern.startsWith("!");
+    const cleanPattern = isNegated ? pattern.slice(1) : pattern;
+    let adjustedPattern = cleanPattern;
+    if (this.config.matchDirectories && !cleanPattern.endsWith("/**")) {
+      adjustedPattern = cleanPattern.endsWith("/") ? `${cleanPattern}**` : `${cleanPattern}/**`;
+    }
+    const regex = minimatch2.makeRe(adjustedPattern, { dot: this.config.matchHidden });
+    return regex || /(?!)/;
+  }
+  /**
+   * Check if file is hidden (starts with .)
+   */
+  isHiddenFile(path) {
+    const parts = path.split("/");
+    return parts.some((part) => part.startsWith(".") && part !== "." && part !== "..");
+  }
+  /**
+   * Generate Cursor-compatible globs field
+   */
+  generateCursorGlobs() {
+    const globs = [...this.config.include];
+    if (this.config.exclude) {
+      for (const pattern of this.config.exclude) {
+        globs.push(`!${pattern}`);
+      }
+    }
+    return globs;
+  }
+  /**
+   * Generate MDC frontmatter
+   */
+  generateMDCFrontmatter() {
+    const globs = this.generateCursorGlobs();
+    return `globs: ${JSON.stringify(globs)}`;
+  }
+};
+function createGlobMatcher(config) {
+  return new GlobMatcher(config);
+}
+function matchPattern(pattern) {
+  return new GlobMatcher({ include: [pattern] });
+}
+function parseGlobsFromMDC(content) {
+  const match = content.match(/globs:\s*(\[.*?\])/s);
+  if (!match) {
+    return null;
+  }
+  try {
+    const patterns = JSON.parse(match[1]);
+    const include = [];
+    const exclude = [];
+    for (const pattern of patterns) {
+      if (pattern.startsWith("!")) {
+        exclude.push(pattern.slice(1));
+      } else {
+        include.push(pattern);
+      }
+    }
+    return { include, exclude };
+  } catch {
+    return null;
+  }
+}
+var COMMON_PATTERNS = {
+  /** All TypeScript files */
+  typescript: ["**/*.ts", "**/*.tsx"],
+  /** All JavaScript files */
+  javascript: ["**/*.js", "**/*.jsx", "**/*.mjs", "**/*.cjs"],
+  /** All test files */
+  tests: ["**/*.test.*", "**/*.spec.*", "**/__tests__/**"],
+  /** All config files */
+  configs: ["*.config.*", "*rc", "*rc.*", "*.json", "*.yaml", "*.yml"],
+  /** All source files */
+  source: ["src/**/*"],
+  /** All documentation */
+  docs: ["**/*.md", "docs/**/*", "README*"],
+  /** Node modules (usually excluded) */
+  nodeModules: ["**/node_modules/**"],
+  /** Build outputs (usually excluded) */
+  buildOutputs: ["**/dist/**", "**/build/**", "**/.next/**"],
+  /** All files */
+  all: ["**/*"]
+};
+function fromCommonPatterns(includeNames, excludeNames) {
+  const include = [];
+  const exclude = [];
+  for (const name of includeNames) {
+    include.push(...COMMON_PATTERNS[name]);
+  }
+  if (excludeNames) {
+    for (const name of excludeNames) {
+      exclude.push(...COMMON_PATTERNS[name]);
+    }
+  }
+  return { include, exclude };
+}
+
+// src/features/bootstrap.ts
+var DEFAULT_FILE_NAMES = {
+  agents: "AGENTS.md",
+  soul: "SOUL.md",
+  tools: "TOOLS.md",
+  identity: "IDENTITY.md",
+  context: "CONTEXT.md",
+  brief: "BRIEF.md",
+  history: "HISTORY.md"
+};
+var BootstrapManager = class {
+  files = /* @__PURE__ */ new Map();
+  /**
+   * Add a bootstrap file
+   */
+  addFile(file) {
+    this.files.set(file.type, file);
+  }
+  /**
+   * Get a bootstrap file by type
+   */
+  getFile(type) {
+    return this.files.get(type);
+  }
+  /**
+   * Get all bootstrap files
+   */
+  getAllFiles() {
+    return Array.from(this.files.values());
+  }
+  /**
+   * Get files sorted by priority
+   */
+  getFilesByPriority() {
+    return this.getAllFiles().sort((a, b) => (b.priority || 0) - (a.priority || 0));
+  }
+  /**
+   * Remove a bootstrap file
+   */
+  removeFile(type) {
+    return this.files.delete(type);
+  }
+  /**
+   * Check if a file type exists
+   */
+  hasFile(type) {
+    return this.files.has(type);
+  }
+  /**
+   * Create AGENTS.md file
+   */
+  createAgentsFile(agents) {
+    const lines = [];
+    lines.push("# Agents");
+    lines.push("");
+    lines.push("This file defines the available agents and their capabilities.");
+    lines.push("");
+    for (const agent of agents) {
+      lines.push(`## ${agent.name}`);
+      lines.push("");
+      if (agent.description) {
+        lines.push(agent.description);
+        lines.push("");
+      }
+      if (agent.capabilities && agent.capabilities.length > 0) {
+        lines.push("### Capabilities");
+        lines.push("");
+        for (const cap of agent.capabilities) {
+          lines.push(`- ${cap}`);
+        }
+        lines.push("");
+      }
+      if (agent.constraints && agent.constraints.length > 0) {
+        lines.push("### Constraints");
+        lines.push("");
+        for (const constraint of agent.constraints) {
+          lines.push(`- ${constraint}`);
+        }
+        lines.push("");
+      }
+    }
+    this.addFile({
+      type: "agents",
+      name: "AGENTS.md",
+      content: lines.join("\n"),
+      priority: 100,
+      required: true
+    });
+  }
+  /**
+   * Create SOUL.md file
+   */
+  createSoulFile(soul) {
+    const lines = [];
+    lines.push("# Soul");
+    lines.push("");
+    lines.push("This file defines the personality and behavior of the agent.");
+    lines.push("");
+    if (soul.personality) {
+      lines.push("## Personality");
+      lines.push("");
+      lines.push(soul.personality);
+      lines.push("");
+    }
+    if (soul.values && soul.values.length > 0) {
+      lines.push("## Values");
+      lines.push("");
+      for (const value of soul.values) {
+        lines.push(`- ${value}`);
+      }
+      lines.push("");
+    }
+    if (soul.communication) {
+      lines.push("## Communication Style");
+      lines.push("");
+      lines.push(soul.communication);
+      lines.push("");
+    }
+    if (soul.rules && soul.rules.length > 0) {
+      lines.push("## Rules");
+      lines.push("");
+      for (const rule of soul.rules) {
+        lines.push(`- ${rule}`);
+      }
+      lines.push("");
+    }
+    this.addFile({
+      type: "soul",
+      name: "SOUL.md",
+      content: lines.join("\n"),
+      priority: 90
+    });
+  }
+  /**
+   * Create TOOLS.md file
+   */
+  createToolsFile(tools) {
+    const lines = [];
+    lines.push("# Tools");
+    lines.push("");
+    lines.push("This file defines the available tools and their usage.");
+    lines.push("");
+    for (const tool of tools) {
+      lines.push(`## ${tool.name}`);
+      lines.push("");
+      if (tool.description) {
+        lines.push(tool.description);
+        lines.push("");
+      }
+      if (tool.usage) {
+        lines.push("### Usage");
+        lines.push("");
+        lines.push("```");
+        lines.push(tool.usage);
+        lines.push("```");
+        lines.push("");
+      }
+      if (tool.examples && tool.examples.length > 0) {
+        lines.push("### Examples");
+        lines.push("");
+        for (const example of tool.examples) {
+          lines.push(`- ${example}`);
+        }
+        lines.push("");
+      }
+    }
+    this.addFile({
+      type: "tools",
+      name: "TOOLS.md",
+      content: lines.join("\n"),
+      priority: 80
+    });
+  }
+  /**
+   * Create IDENTITY.md file
+   */
+  createIdentityFile(identity) {
+    const lines = [];
+    lines.push("# Identity");
+    lines.push("");
+    if (identity.name) {
+      lines.push(`**Name:** ${identity.name}`);
+      lines.push("");
+    }
+    if (identity.role) {
+      lines.push(`**Role:** ${identity.role}`);
+      lines.push("");
+    }
+    if (identity.description) {
+      lines.push("## Description");
+      lines.push("");
+      lines.push(identity.description);
+      lines.push("");
+    }
+    if (identity.expertise && identity.expertise.length > 0) {
+      lines.push("## Expertise");
+      lines.push("");
+      for (const exp of identity.expertise) {
+        lines.push(`- ${exp}`);
+      }
+      lines.push("");
+    }
+    this.addFile({
+      type: "identity",
+      name: "IDENTITY.md",
+      content: lines.join("\n"),
+      priority: 95
+    });
+  }
+  /**
+   * Create CONTEXT.md file
+   */
+  createContextFile(context) {
+    const lines = [];
+    lines.push("# Context");
+    lines.push("");
+    if (context.project) {
+      lines.push("## Project");
+      lines.push("");
+      lines.push(context.project);
+      lines.push("");
+    }
+    if (context.techStack && context.techStack.length > 0) {
+      lines.push("## Tech Stack");
+      lines.push("");
+      for (const tech of context.techStack) {
+        lines.push(`- ${tech}`);
+      }
+      lines.push("");
+    }
+    if (context.conventions && context.conventions.length > 0) {
+      lines.push("## Conventions");
+      lines.push("");
+      for (const conv of context.conventions) {
+        lines.push(`- ${conv}`);
+      }
+      lines.push("");
+    }
+    if (context.currentTask) {
+      lines.push("## Current Task");
+      lines.push("");
+      lines.push(context.currentTask);
+      lines.push("");
+    }
+    this.addFile({
+      type: "context",
+      name: "CONTEXT.md",
+      content: lines.join("\n"),
+      priority: 70
+    });
+  }
+  /**
+   * Generate all files as a map
+   */
+  generateFiles() {
+    const files = /* @__PURE__ */ new Map();
+    for (const file of this.getFilesByPriority()) {
+      files.set(file.name, file.content);
+    }
+    return files;
+  }
+  /**
+   * Generate combined content for agents without file support
+   */
+  generateCombinedContent() {
+    const lines = [];
+    for (const file of this.getFilesByPriority()) {
+      lines.push(`<!-- ${file.name} -->`);
+      lines.push("");
+      lines.push(file.content);
+      lines.push("");
+      lines.push("---");
+      lines.push("");
+    }
+    return lines.join("\n");
+  }
+  /**
+   * Get default file name for a type
+   */
+  static getDefaultFileName(type) {
+    return DEFAULT_FILE_NAMES[type];
+  }
+};
+function createBootstrapManager() {
+  return new BootstrapManager();
+}
+function createBootstrapSet(options) {
+  const manager = new BootstrapManager();
+  if (options.agents) {
+    manager.createAgentsFile(options.agents);
+  }
+  if (options.soul) {
+    manager.createSoulFile(options.soul);
+  }
+  if (options.tools) {
+    manager.createToolsFile(options.tools);
+  }
+  if (options.identity) {
+    manager.createIdentityFile(options.identity);
+  }
+  if (options.context) {
+    manager.createContextFile(options.context);
+  }
+  return manager;
+}
+
+// src/features/modes.ts
+var DEFAULT_MODES = {
+  code: {
+    mode: "code",
+    description: "Code editing and implementation mode",
+    promptPrefix: "You are in code mode. Focus on writing and editing code."
+  },
+  architect: {
+    mode: "architect",
+    description: "Architecture and planning mode",
+    promptPrefix: "You are in architect mode. Focus on system design and planning."
+  },
+  ask: {
+    mode: "ask",
+    description: "Question and answer mode",
+    promptPrefix: "You are in ask mode. Focus on answering questions clearly."
+  },
+  debug: {
+    mode: "debug",
+    description: "Debugging and troubleshooting mode",
+    promptPrefix: "You are in debug mode. Focus on finding and fixing issues."
+  },
+  review: {
+    mode: "review",
+    description: "Code review mode",
+    promptPrefix: "You are in review mode. Focus on reviewing code quality."
+  },
+  test: {
+    mode: "test",
+    description: "Testing mode",
+    promptPrefix: "You are in test mode. Focus on writing and running tests."
+  },
+  docs: {
+    mode: "docs",
+    description: "Documentation mode",
+    promptPrefix: "You are in docs mode. Focus on writing documentation."
+  }
+};
+var ModeManager = class {
+  modes = /* @__PURE__ */ new Map();
+  currentMode = "code";
+  modeListeners = /* @__PURE__ */ new Set();
+  constructor(modes) {
+    if (modes) {
+      for (const mode of modes) {
+        this.addMode(mode);
+      }
+    }
+  }
+  /**
+   * Add a mode configuration
+   */
+  addMode(config) {
+    this.modes.set(config.mode, config);
+  }
+  /**
+   * Get a mode configuration
+   */
+  getMode(mode) {
+    return this.modes.get(mode);
+  }
+  /**
+   * Get all mode configurations
+   */
+  getAllModes() {
+    return Array.from(this.modes.values());
+  }
+  /**
+   * Get available mode names
+   */
+  getAvailableModes() {
+    return Array.from(this.modes.keys());
+  }
+  /**
+   * Set the current mode
+   */
+  setMode(mode) {
+    const config = this.modes.get(mode);
+    if (!config) {
+      throw new Error(`Mode not configured: ${mode}`);
+    }
+    const previousMode = this.currentMode;
+    this.currentMode = mode;
+    for (const listener of this.modeListeners) {
+      listener(mode, previousMode, config);
+    }
+  }
+  /**
+   * Get the current mode
+   */
+  getCurrentMode() {
+    return this.currentMode;
+  }
+  /**
+   * Get current mode configuration
+   */
+  getCurrentModeConfig() {
+    return this.modes.get(this.currentMode);
+  }
+  /**
+   * Get skills for current mode
+   */
+  getCurrentSkills() {
+    const config = this.getCurrentModeConfig();
+    return config?.skills || [];
+  }
+  /**
+   * Get tools for current mode
+   */
+  getCurrentTools() {
+    const config = this.getCurrentModeConfig();
+    return config?.tools || [];
+  }
+  /**
+   * Check if a skill is available in current mode
+   */
+  isSkillAvailable(skillName) {
+    const skills = this.getCurrentSkills();
+    return skills.length === 0 || skills.includes(skillName);
+  }
+  /**
+   * Check if a file is allowed in current mode
+   */
+  isFileAllowed(filePath) {
+    const config = this.getCurrentModeConfig();
+    if (!config?.allowedFiles || config.allowedFiles.length === 0) {
+      return true;
+    }
+    const matcher = new GlobMatcher({ include: config.allowedFiles });
+    return matcher.matches(filePath);
+  }
+  /**
+   * Add mode change listener
+   */
+  addModeListener(listener) {
+    this.modeListeners.add(listener);
+  }
+  /**
+   * Remove mode change listener
+   */
+  removeModeListener(listener) {
+    this.modeListeners.delete(listener);
+  }
+  /**
+   * Create a mode from default configuration
+   */
+  addDefaultMode(mode, skills) {
+    const defaultConfig = DEFAULT_MODES[mode];
+    this.addMode({
+      ...defaultConfig,
+      skills
+    });
+  }
+  /**
+   * Generate mode-specific prompt prefix
+   */
+  getPromptPrefix() {
+    const config = this.getCurrentModeConfig();
+    return config?.promptPrefix || "";
+  }
+  /**
+   * Generate Roo-compatible mode configuration
+   */
+  generateRooConfig() {
+    const modes = {};
+    for (const config of this.modes.values()) {
+      modes[config.mode] = {
+        description: config.description,
+        skills: config.skills,
+        tools: config.tools,
+        promptPrefix: config.promptPrefix
+      };
+    }
+    return {
+      defaultMode: this.currentMode,
+      modes
+    };
+  }
+  /**
+   * Generate mode documentation
+   */
+  generateModeDocumentation() {
+    const lines = [];
+    lines.push("# Available Modes");
+    lines.push("");
+    for (const config of this.modes.values()) {
+      lines.push(`## ${config.mode}`);
+      lines.push("");
+      lines.push(config.description);
+      lines.push("");
+      if (config.skills.length > 0) {
+        lines.push("### Skills");
+        lines.push("");
+        for (const skill of config.skills) {
+          lines.push(`- ${skill}`);
+        }
+        lines.push("");
+      }
+      if (config.tools && config.tools.length > 0) {
+        lines.push("### Tools");
+        lines.push("");
+        for (const tool of config.tools) {
+          lines.push(`- ${tool}`);
+        }
+        lines.push("");
+      }
+    }
+    return lines.join("\n");
+  }
+};
+function createModeManager(modes) {
+  return new ModeManager(modes);
+}
+function createDefaultModeManager(skillsPerMode) {
+  const manager = new ModeManager();
+  for (const [mode, config] of Object.entries(DEFAULT_MODES)) {
+    const skills = skillsPerMode[mode] || [];
+    manager.addMode({
+      ...config,
+      skills
+    });
+  }
+  return manager;
+}
+function getDefaultModeConfig(mode) {
+  return DEFAULT_MODES[mode];
+}
+var ALL_MODES = ["code", "architect", "ask", "debug", "review", "test", "docs"];
+
 // src/index.ts
 var adapters = {
   "claude-code": new ClaudeCodeAdapter(),
@@ -1162,8 +2069,11 @@ function getConfigFile(type) {
   return adapters[type].configFile;
 }
 export {
+  ALL_MODES,
   AmpAdapter,
   AntigravityAdapter,
+  BootstrapManager,
+  COMMON_PATTERNS,
   ClaudeCodeAdapter,
   ClawdbotAdapter,
   CodexAdapter,
@@ -1171,20 +2081,36 @@ export {
   DroidAdapter,
   GeminiCliAdapter,
   GitHubCopilotAdapter,
+  GlobMatcher,
   GooseAdapter,
   KiloAdapter,
   KiroCliAdapter,
+  ModeManager,
   OpenCodeAdapter,
+  PermissionManager,
   RooAdapter,
   TraeAdapter,
   UniversalAdapter,
   WindsurfAdapter,
+  createBootstrapManager,
+  createBootstrapSet,
+  createDefaultModeManager,
+  createGlobMatcher,
+  createModeManager,
+  createPermissionManager,
   createSkillXml,
   detectAgent,
   escapeXml,
+  fromCommonPatterns,
   getAdapter,
   getAllAdapters,
   getConfigFile,
-  getSkillsDir
+  getDefaultModeConfig,
+  getSkillsDir,
+  isAllowed,
+  isDenied,
+  matchPattern,
+  needsConfirmation,
+  parseGlobsFromMDC
 };
 //# sourceMappingURL=index.js.map