@skillkit/agents 1.7.6 → 1.7.8

package/dist/index.js

@@ -603,17 +603,81 @@ ${skillsXml}
   }
 };
 
-// src/github-copilot.ts
+// src/factory.ts
 import { existsSync as existsSync10 } from "fs";
 import { join as join10 } from "path";
 import { homedir as homedir10 } from "os";
 import { AGENT_CONFIG as AGENT_CONFIG10 } from "@skillkit/core";
-var config10 = AGENT_CONFIG10["github-copilot"];
+var config10 = AGENT_CONFIG10.factory;
+var FactoryAdapter = class {
+  type = "factory";
+  name = "Factory";
+  skillsDir = config10.skillsDir;
+  configFile = config10.configFile;
+  generateConfig(skills) {
+    const enabledSkills = skills.filter((s) => s.enabled);
+    if (enabledSkills.length === 0) {
+      return "";
+    }
+    const skillsXml = enabledSkills.map(createSkillXml).join("\n\n");
+    return `<skills_system priority="1">
+
+## Available Skills
+
+<!-- SKILLS_TABLE_START -->
+<usage>
+When users ask you to perform tasks, check if any of the available skills below can help complete the task more effectively. Skills provide specialized capabilities and domain knowledge.
+
+How to use skills:
+- Invoke: \`skillkit read <skill-name>\` or \`npx skillkit read <skill-name>\`
+- The skill content will load with detailed instructions on how to complete the task
+- Base directory provided in output for resolving bundled resources (references/, scripts/, assets/)
+
+Usage notes:
+- Only use skills listed in <available_skills> below
+- Do not invoke a skill that is already loaded in your context
+- Each skill invocation is stateless
+</usage>
+
+<available_skills>
+
+${skillsXml}
+
+</available_skills>
+<!-- SKILLS_TABLE_END -->
+
+</skills_system>`;
+  }
+  parseConfig(content) {
+    const skillNames = [];
+    const skillRegex = /<name>([^<]+)<\/name>/g;
+    let match;
+    while ((match = skillRegex.exec(content)) !== null) {
+      skillNames.push(match[1].trim());
+    }
+    return skillNames;
+  }
+  getInvokeCommand(skillName) {
+    return `skillkit read ${skillName}`;
+  }
+  async isDetected() {
+    const projectFactory = join10(process.cwd(), ".factory");
+    const globalFactory = join10(homedir10(), ".factory");
+    return existsSync10(projectFactory) || existsSync10(globalFactory);
+  }
+};
+
+// src/github-copilot.ts
+import { existsSync as existsSync11 } from "fs";
+import { join as join11 } from "path";
+import { homedir as homedir11 } from "os";
+import { AGENT_CONFIG as AGENT_CONFIG11 } from "@skillkit/core";
+var config11 = AGENT_CONFIG11["github-copilot"];
 var GitHubCopilotAdapter = class {
   type = "github-copilot";
   name = "GitHub Copilot";
-  skillsDir = config10.skillsDir;
-  configFile = config10.configFile;
+  skillsDir = config11.skillsDir;
+  configFile = config11.configFile;
   generateConfig(skills) {
     const enabledSkills = skills.filter((s) => s.enabled);
     if (enabledSkills.length === 0) {
@@ -658,24 +722,24 @@ Each skill is self-contained with its own resources.
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const copilotInstructions = join10(process.cwd(), ".github", "copilot-instructions.md");
-    const githubInstructions = join10(process.cwd(), ".github", "instructions");
-    const globalCopilot = join10(homedir10(), ".copilot");
-    return existsSync10(copilotInstructions) || existsSync10(githubInstructions) || existsSync10(globalCopilot);
+    const copilotInstructions = join11(process.cwd(), ".github", "copilot-instructions.md");
+    const githubInstructions = join11(process.cwd(), ".github", "instructions");
+    const globalCopilot = join11(homedir11(), ".copilot");
+    return existsSync11(copilotInstructions) || existsSync11(githubInstructions) || existsSync11(globalCopilot);
   }
 };
 
 // src/goose.ts
-import { existsSync as existsSync11 } from "fs";
-import { join as join11 } from "path";
-import { homedir as homedir11 } from "os";
-import { AGENT_CONFIG as AGENT_CONFIG11 } from "@skillkit/core";
-var config11 = AGENT_CONFIG11.goose;
+import { existsSync as existsSync12 } from "fs";
+import { join as join12 } from "path";
+import { homedir as homedir12 } from "os";
+import { AGENT_CONFIG as AGENT_CONFIG12 } from "@skillkit/core";
+var config12 = AGENT_CONFIG12.goose;
 var GooseAdapter = class {
   type = "goose";
   name = "Goose";
-  skillsDir = config11.skillsDir;
-  configFile = config11.configFile;
+  skillsDir = config12.skillsDir;
+  configFile = config12.configFile;
   generateConfig(skills) {
     const enabledSkills = skills.filter((s) => s.enabled);
     if (enabledSkills.length === 0) {
@@ -723,23 +787,23 @@ ${skillsXml}
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const projectGoose = join11(process.cwd(), ".goose");
-    const globalGoose = join11(homedir11(), ".config", "goose");
-    return existsSync11(projectGoose) || existsSync11(globalGoose);
+    const projectGoose = join12(process.cwd(), ".goose");
+    const globalGoose = join12(homedir12(), ".config", "goose");
+    return existsSync12(projectGoose) || existsSync12(globalGoose);
   }
 };
 
 // src/kilo.ts
-import { existsSync as existsSync12 } from "fs";
-import { join as join12 } from "path";
-import { homedir as homedir12 } from "os";
-import { AGENT_CONFIG as AGENT_CONFIG12 } from "@skillkit/core";
-var config12 = AGENT_CONFIG12.kilo;
+import { existsSync as existsSync13 } from "fs";
+import { join as join13 } from "path";
+import { homedir as homedir13 } from "os";
+import { AGENT_CONFIG as AGENT_CONFIG13 } from "@skillkit/core";
+var config13 = AGENT_CONFIG13.kilo;
 var KiloAdapter = class {
   type = "kilo";
   name = "Kilo Code";
-  skillsDir = config12.skillsDir;
-  configFile = config12.configFile;
+  skillsDir = config13.skillsDir;
+  configFile = config13.configFile;
   generateConfig(skills) {
     const enabledSkills = skills.filter((s) => s.enabled);
     if (enabledSkills.length === 0) {
@@ -787,24 +851,24 @@ ${skillsXml}
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const projectKilo = join12(process.cwd(), ".kilocode");
-    const globalKilo = join12(homedir12(), ".kilocode");
-    const kiloModes = join12(process.cwd(), ".kilocode", "modes");
-    return existsSync12(projectKilo) || existsSync12(globalKilo) || existsSync12(kiloModes);
+    const projectKilo = join13(process.cwd(), ".kilocode");
+    const globalKilo = join13(homedir13(), ".kilocode");
+    const kiloModes = join13(process.cwd(), ".kilocode", "modes");
+    return existsSync13(projectKilo) || existsSync13(globalKilo) || existsSync13(kiloModes);
   }
 };
 
 // src/kiro-cli.ts
-import { existsSync as existsSync13 } from "fs";
-import { join as join13 } from "path";
-import { homedir as homedir13 } from "os";
-import { AGENT_CONFIG as AGENT_CONFIG13 } from "@skillkit/core";
-var config13 = AGENT_CONFIG13["kiro-cli"];
+import { existsSync as existsSync14 } from "fs";
+import { join as join14 } from "path";
+import { homedir as homedir14 } from "os";
+import { AGENT_CONFIG as AGENT_CONFIG14 } from "@skillkit/core";
+var config14 = AGENT_CONFIG14["kiro-cli"];
 var KiroCliAdapter = class {
   type = "kiro-cli";
   name = "Kiro CLI";
-  skillsDir = config13.skillsDir;
-  configFile = config13.configFile;
+  skillsDir = config14.skillsDir;
+  configFile = config14.configFile;
   generateConfig(skills) {
     const enabledSkills = skills.filter((s) => s.enabled);
     if (enabledSkills.length === 0) {
@@ -862,23 +926,23 @@ ${skillsXml}
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const projectKiro = join13(process.cwd(), ".kiro");
-    const globalKiro = join13(homedir13(), ".kiro");
-    return existsSync13(projectKiro) || existsSync13(globalKiro);
+    const projectKiro = join14(process.cwd(), ".kiro");
+    const globalKiro = join14(homedir14(), ".kiro");
+    return existsSync14(projectKiro) || existsSync14(globalKiro);
   }
 };
 
 // src/roo.ts
-import { existsSync as existsSync14 } from "fs";
-import { join as join14 } from "path";
-import { homedir as homedir14 } from "os";
-import { AGENT_CONFIG as AGENT_CONFIG14 } from "@skillkit/core";
-var config14 = AGENT_CONFIG14.roo;
+import { existsSync as existsSync15 } from "fs";
+import { join as join15 } from "path";
+import { homedir as homedir15 } from "os";
+import { AGENT_CONFIG as AGENT_CONFIG15 } from "@skillkit/core";
+var config15 = AGENT_CONFIG15.roo;
 var RooAdapter = class {
   type = "roo";
   name = "Roo Code";
-  skillsDir = config14.skillsDir;
-  configFile = config14.configFile;
+  skillsDir = config15.skillsDir;
+  configFile = config15.configFile;
   generateConfig(skills) {
     const enabledSkills = skills.filter((s) => s.enabled);
     if (enabledSkills.length === 0) {
@@ -926,24 +990,24 @@ ${skillsXml}
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const projectRoo = join14(process.cwd(), ".roo");
-    const globalRoo = join14(homedir14(), ".roo");
-    const rooModes = join14(process.cwd(), ".roo", "modes");
-    return existsSync14(projectRoo) || existsSync14(globalRoo) || existsSync14(rooModes);
+    const projectRoo = join15(process.cwd(), ".roo");
+    const globalRoo = join15(homedir15(), ".roo");
+    const rooModes = join15(process.cwd(), ".roo", "modes");
+    return existsSync15(projectRoo) || existsSync15(globalRoo) || existsSync15(rooModes);
   }
 };
 
 // src/trae.ts
-import { existsSync as existsSync15 } from "fs";
-import { join as join15 } from "path";
-import { homedir as homedir15 } from "os";
-import { AGENT_CONFIG as AGENT_CONFIG15 } from "@skillkit/core";
-var config15 = AGENT_CONFIG15.trae;
+import { existsSync as existsSync16 } from "fs";
+import { join as join16 } from "path";
+import { homedir as homedir16 } from "os";
+import { AGENT_CONFIG as AGENT_CONFIG16 } from "@skillkit/core";
+var config16 = AGENT_CONFIG16.trae;
 var TraeAdapter = class {
   type = "trae";
   name = "Trae";
-  skillsDir = config15.skillsDir;
-  configFile = config15.configFile;
+  skillsDir = config16.skillsDir;
+  configFile = config16.configFile;
   generateConfig(skills) {
     const enabledSkills = skills.filter((s) => s.enabled);
     if (enabledSkills.length === 0) {
@@ -992,24 +1056,24 @@ Skills provide detailed instructions for completing complex tasks.
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const projectTrae = join15(process.cwd(), ".trae");
-    const traeRulesDir = join15(process.cwd(), ".trae", "rules");
-    const globalTrae = join15(homedir15(), ".trae");
-    return existsSync15(projectTrae) || existsSync15(traeRulesDir) || existsSync15(globalTrae);
+    const projectTrae = join16(process.cwd(), ".trae");
+    const traeRulesDir = join16(process.cwd(), ".trae", "rules");
+    const globalTrae = join16(homedir16(), ".trae");
+    return existsSync16(projectTrae) || existsSync16(traeRulesDir) || existsSync16(globalTrae);
   }
 };
 
 // src/windsurf.ts
-import { existsSync as existsSync16 } from "fs";
-import { join as join16 } from "path";
-import { homedir as homedir16 } from "os";
-import { AGENT_CONFIG as AGENT_CONFIG16 } from "@skillkit/core";
-var config16 = AGENT_CONFIG16.windsurf;
+import { existsSync as existsSync17 } from "fs";
+import { join as join17 } from "path";
+import { homedir as homedir17 } from "os";
+import { AGENT_CONFIG as AGENT_CONFIG17 } from "@skillkit/core";
+var config17 = AGENT_CONFIG17.windsurf;
 var WindsurfAdapter = class {
   type = "windsurf";
   name = "Windsurf";
-  skillsDir = config16.skillsDir;
-  configFile = config16.configFile;
+  skillsDir = config17.skillsDir;
+  configFile = config17.configFile;
   generateConfig(skills) {
     const enabledSkills = skills.filter((s) => s.enabled);
     if (enabledSkills.length === 0) {
@@ -1058,23 +1122,23 @@ Each skill is self-contained with its own resources.
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const projectWindsurf = join16(process.cwd(), ".windsurf");
-    const projectRulesDir = join16(process.cwd(), ".windsurf", "rules");
-    const globalWindsurf = join16(homedir16(), ".codeium", "windsurf");
-    return existsSync16(projectWindsurf) || existsSync16(projectRulesDir) || existsSync16(globalWindsurf);
+    const projectWindsurf = join17(process.cwd(), ".windsurf");
+    const projectRulesDir = join17(process.cwd(), ".windsurf", "rules");
+    const globalWindsurf = join17(homedir17(), ".codeium", "windsurf");
+    return existsSync17(projectWindsurf) || existsSync17(projectRulesDir) || existsSync17(globalWindsurf);
   }
 };
 
 // src/universal.ts
-import { existsSync as existsSync17 } from "fs";
-import { join as join17 } from "path";
-import { AGENT_CONFIG as AGENT_CONFIG17 } from "@skillkit/core";
-var config17 = AGENT_CONFIG17.universal;
+import { existsSync as existsSync18 } from "fs";
+import { join as join18 } from "path";
+import { AGENT_CONFIG as AGENT_CONFIG18 } from "@skillkit/core";
+var config18 = AGENT_CONFIG18.universal;
 var UniversalAdapter = class {
   type = "universal";
   name = "Universal (Any Agent)";
-  skillsDir = config17.skillsDir;
-  configFile = config17.configFile;
+  skillsDir = config18.skillsDir;
+  configFile = config18.configFile;
   generateConfig(skills) {
     const enabledSkills = skills.filter((s) => s.enabled);
     if (enabledSkills.length === 0) {
@@ -1144,9 +1208,9 @@ ${skillsXml}
     return `skillkit read ${skillName}`;
   }
   async isDetected() {
-    const agentDir = join17(process.cwd(), ".agent");
-    const agentsMd = join17(process.cwd(), "AGENTS.md");
-    return existsSync17(agentDir) || existsSync17(agentsMd);
+    const agentDir = join18(process.cwd(), ".agent");
+    const agentsMd = join18(process.cwd(), "AGENTS.md");
+    return existsSync18(agentDir) || existsSync18(agentsMd);
   }
 };
 
@@ -1154,14 +1218,14 @@ ${skillsXml}
 import { minimatch } from "minimatch";
 var PermissionManager = class {
   config;
-  constructor(config18) {
-    this.config = config18 || { default: "ask" };
+  constructor(config19) {
+    this.config = config19 || { default: "ask" };
   }
   /**
    * Set permission configuration
    */
-  setConfig(config18) {
-    this.config = config18;
+  setConfig(config19) {
+    this.config = config19;
   }
   /**
    * Get permission configuration
@@ -1309,20 +1373,20 @@ var PermissionManager = class {
    * Parse permissions from SKILL.md metadata
    */
   static fromMetadata(metadata) {
-    const config18 = {};
+    const config19 = {};
     if (metadata.filePermissions && Array.isArray(metadata.filePermissions)) {
-      config18.files = metadata.filePermissions;
+      config19.files = metadata.filePermissions;
     }
     if (metadata.commandPermissions && Array.isArray(metadata.commandPermissions)) {
-      config18.commands = metadata.commandPermissions;
+      config19.commands = metadata.commandPermissions;
     }
     if (metadata.networkPermissions && Array.isArray(metadata.networkPermissions)) {
-      config18.network = metadata.networkPermissions;
+      config19.network = metadata.networkPermissions;
     }
     if (metadata.defaultPermission) {
-      config18.default = metadata.defaultPermission;
+      config19.default = metadata.defaultPermission;
     }
-    return config18;
+    return config19;
   }
   /**
    * Merge two permission configs
@@ -1337,8 +1401,8 @@ var PermissionManager = class {
     };
   }
 };
-function createPermissionManager(config18) {
-  return new PermissionManager(config18);
+function createPermissionManager(config19) {
+  return new PermissionManager(config19);
 }
 function isAllowed(level) {
   return level === "allow";
@@ -1356,10 +1420,10 @@ var GlobMatcher = class {
   config;
   includePatterns;
   excludePatterns;
-  constructor(config18) {
-    this.config = config18;
-    this.includePatterns = config18.include.map((p) => this.patternToRegex(p));
-    this.excludePatterns = (config18.exclude || []).map((p) => this.patternToRegex(p));
+  constructor(config19) {
+    this.config = config19;
+    this.includePatterns = config19.include.map((p) => this.patternToRegex(p));
+    this.excludePatterns = (config19.exclude || []).map((p) => this.patternToRegex(p));
   }
   /**
    * Check if a file matches the glob patterns
@@ -1459,8 +1523,8 @@ var GlobMatcher = class {
     return `globs: ${JSON.stringify(globs)}`;
   }
 };
-function createGlobMatcher(config18) {
-  return new GlobMatcher(config18);
+function createGlobMatcher(config19) {
+  return new GlobMatcher(config19);
 }
 function matchPattern(pattern) {
   return new GlobMatcher({ include: [pattern] });
@@ -1878,8 +1942,8 @@ var ModeManager = class {
   /**
    * Add a mode configuration
    */
-  addMode(config18) {
-    this.modes.set(config18.mode, config18);
+  addMode(config19) {
+    this.modes.set(config19.mode, config19);
   }
   /**
    * Get a mode configuration
@@ -1903,14 +1967,14 @@ var ModeManager = class {
    * Set the current mode
    */
   setMode(mode) {
-    const config18 = this.modes.get(mode);
-    if (!config18) {
+    const config19 = this.modes.get(mode);
+    if (!config19) {
       throw new Error(`Mode not configured: ${mode}`);
     }
     const previousMode = this.currentMode;
     this.currentMode = mode;
     for (const listener of this.modeListeners) {
-      listener(mode, previousMode, config18);
+      listener(mode, previousMode, config19);
     }
   }
   /**
@@ -1929,15 +1993,15 @@ var ModeManager = class {
    * Get skills for current mode
    */
   getCurrentSkills() {
-    const config18 = this.getCurrentModeConfig();
-    return config18?.skills || [];
+    const config19 = this.getCurrentModeConfig();
+    return config19?.skills || [];
   }
   /**
    * Get tools for current mode
    */
   getCurrentTools() {
-    const config18 = this.getCurrentModeConfig();
-    return config18?.tools || [];
+    const config19 = this.getCurrentModeConfig();
+    return config19?.tools || [];
   }
   /**
    * Check if a skill is available in current mode
@@ -1950,11 +2014,11 @@ var ModeManager = class {
    * Check if a file is allowed in current mode
    */
   isFileAllowed(filePath) {
-    const config18 = this.getCurrentModeConfig();
-    if (!config18?.allowedFiles || config18.allowedFiles.length === 0) {
+    const config19 = this.getCurrentModeConfig();
+    if (!config19?.allowedFiles || config19.allowedFiles.length === 0) {
       return true;
     }
-    const matcher = new GlobMatcher({ include: config18.allowedFiles });
+    const matcher = new GlobMatcher({ include: config19.allowedFiles });
     return matcher.matches(filePath);
   }
   /**
@@ -1983,20 +2047,20 @@ var ModeManager = class {
    * Generate mode-specific prompt prefix
    */
   getPromptPrefix() {
-    const config18 = this.getCurrentModeConfig();
-    return config18?.promptPrefix || "";
+    const config19 = this.getCurrentModeConfig();
+    return config19?.promptPrefix || "";
   }
   /**
    * Generate Roo-compatible mode configuration
    */
   generateRooConfig() {
     const modes = {};
-    for (const config18 of this.modes.values()) {
-      modes[config18.mode] = {
-        description: config18.description,
-        skills: config18.skills,
-        tools: config18.tools,
-        promptPrefix: config18.promptPrefix
+    for (const config19 of this.modes.values()) {
+      modes[config19.mode] = {
+        description: config19.description,
+        skills: config19.skills,
+        tools: config19.tools,
+        promptPrefix: config19.promptPrefix
       };
     }
     return {
@@ -2011,23 +2075,23 @@ var ModeManager = class {
     const lines = [];
     lines.push("# Available Modes");
     lines.push("");
-    for (const config18 of this.modes.values()) {
-      lines.push(`## ${config18.mode}`);
+    for (const config19 of this.modes.values()) {
+      lines.push(`## ${config19.mode}`);
       lines.push("");
-      lines.push(config18.description);
+      lines.push(config19.description);
       lines.push("");
-      if (config18.skills.length > 0) {
+      if (config19.skills.length > 0) {
         lines.push("### Skills");
         lines.push("");
-        for (const skill of config18.skills) {
+        for (const skill of config19.skills) {
           lines.push(`- ${skill}`);
         }
         lines.push("");
       }
-      if (config18.tools && config18.tools.length > 0) {
+      if (config19.tools && config19.tools.length > 0) {
         lines.push("### Tools");
         lines.push("");
-        for (const tool of config18.tools) {
+        for (const tool of config19.tools) {
           lines.push(`- ${tool}`);
         }
         lines.push("");
@@ -2041,10 +2105,10 @@ function createModeManager(modes) {
 }
 function createDefaultModeManager(skillsPerMode) {
   const manager = new ModeManager();
-  for (const [mode, config18] of Object.entries(DEFAULT_MODES)) {
+  for (const [mode, config19] of Object.entries(DEFAULT_MODES)) {
     const skills = skillsPerMode[mode] || [];
     manager.addMode({
-      ...config18,
+      ...config19,
       skills
     });
   }
@@ -2073,7 +2137,22 @@ var adapters = {
   roo: new RooAdapter(),
   trae: new TraeAdapter(),
   windsurf: new WindsurfAdapter(),
-  universal: new UniversalAdapter()
+  universal: new UniversalAdapter(),
+  cline: new UniversalAdapter(),
+  codebuddy: new UniversalAdapter(),
+  commandcode: new UniversalAdapter(),
+  continue: new UniversalAdapter(),
+  crush: new UniversalAdapter(),
+  factory: new FactoryAdapter(),
+  mcpjam: new UniversalAdapter(),
+  mux: new UniversalAdapter(),
+  neovate: new UniversalAdapter(),
+  openhands: new UniversalAdapter(),
+  pi: new UniversalAdapter(),
+  qoder: new UniversalAdapter(),
+  qwen: new UniversalAdapter(),
+  vercel: new UniversalAdapter(),
+  zencoder: new UniversalAdapter()
 };
 function getAdapter(type) {
   return adapters[type];
@@ -2099,6 +2178,21 @@ async function detectAgent() {
     "roo",
     "trae",
     "windsurf",
+    "cline",
+    "codebuddy",
+    "commandcode",
+    "continue",
+    "crush",
+    "factory",
+    "mcpjam",
+    "mux",
+    "neovate",
+    "openhands",
+    "pi",
+    "qoder",
+    "qwen",
+    "vercel",
+    "zencoder",
     "universal"
   ];
   for (const type of checkOrder) {
@@ -2120,6 +2214,7 @@ export {
   CodexAdapter,
   CursorAdapter,
   DroidAdapter,
+  FactoryAdapter,
   GeminiCliAdapter,
   GitHubCopilotAdapter,
   GlobMatcher,