oricore 1.5.0 → 1.5.2

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   Session,
   SessionConfigManager,
   loadSessionMessages
-} from "./chunk-OYWDQD3F.js";
+} from "./chunk-P4RPHQOE.js";
 import {
   Compression,
   ConfigManager,
@@ -19,8 +19,10 @@ import {
   resolveTools,
   runLoop,
   safeStringify
-} from "./chunk-4QYFQSAC.js";
-import "./chunk-DO76AL42.js";
+} from "./chunk-E7TB3WLC.js";
+import {
+  __require
+} from "./chunk-D5X6YFSK.js";
 
 // src/core/context.ts
 import fs10 from "fs";
@@ -2443,6 +2445,116 @@ import degit from "degit";
 import fs9 from "fs";
 import os3 from "os";
 import path9 from "pathe";
+
+// src/skill/bundled.ts
+var BundledSkillRegistry = class {
+  skills = /* @__PURE__ */ new Map();
+  aliases = /* @__PURE__ */ new Map();
+  /**
+   * Register a bundled skill.
+   * @param definition The skill definition
+   */
+  register(definition) {
+    if (!definition.name) {
+      throw new Error("Bundled skill must have a name");
+    }
+    if (!definition.description) {
+      throw new Error("Bundled skill must have a description");
+    }
+    if (!definition.getPrompt) {
+      throw new Error("Bundled skill must have a getPrompt function");
+    }
+    this.skills.set(definition.name, definition);
+    if (definition.aliases) {
+      for (const alias of definition.aliases) {
+        this.aliases.set(alias, definition.name);
+      }
+    }
+  }
+  /**
+   * Get a bundled skill by name or alias.
+   * @param name Skill name or alias
+   * @returns The skill definition or undefined if not found
+   */
+  get(name) {
+    const skill = this.skills.get(name);
+    if (skill) return skill;
+    const aliasedName = this.aliases.get(name);
+    if (aliasedName) {
+      return this.skills.get(aliasedName);
+    }
+    return void 0;
+  }
+  /**
+   * Get all registered bundled skills.
+   * @param context Optional context to filter by isEnabled
+   * @returns Array of skill definitions
+   */
+  getAll(context) {
+    return Array.from(this.skills.values()).filter((skill) => {
+      if (skill.isEnabled === void 0) return true;
+      if (typeof skill.isEnabled === "boolean") return skill.isEnabled;
+      if (typeof skill.isEnabled === "function" && context) {
+        return skill.isEnabled(context);
+      }
+      return true;
+    });
+  }
+  /**
+   * Check if a skill is registered.
+   * @param name Skill name or alias
+   */
+  has(name) {
+    return this.skills.has(name) || this.aliases.has(name);
+  }
+  /**
+   * Unregister a skill.
+   * @param name Skill name
+   */
+  unregister(name) {
+    const skill = this.skills.get(name);
+    if (skill && skill.aliases) {
+      for (const alias of skill.aliases) {
+        this.aliases.delete(alias);
+      }
+    }
+    this.skills.delete(name);
+  }
+  /**
+   * Clear all registered skills.
+   */
+  clear() {
+    this.skills.clear();
+    this.aliases.clear();
+  }
+};
+var bundledSkillRegistry = new BundledSkillRegistry();
+function bundledSkillToMetadata(definition, source = "builtin") {
+  return {
+    name: definition.name,
+    description: definition.description,
+    path: `bundled://${definition.name}`,
+    source,
+    allowedTools: definition.allowedTools,
+    context: definition.context,
+    agent: definition.agent,
+    userInvocable: definition.userInvocable ?? true,
+    modelInvocable: definition.modelInvocable ?? true
+    // Note: bundled skills don't support 'paths' conditional activation
+  };
+}
+function createBundledSkill(config) {
+  return {
+    ...config,
+    getPrompt: typeof config.prompt === "string" ? () => config.prompt : config.prompt
+  };
+}
+function registerBundledSkill(config) {
+  const skill = createBundledSkill(config);
+  bundledSkillRegistry.register(skill);
+}
+
+// src/skill/skill.ts
 function isDirOrSymlinkToDir(parentDir, entry) {
   if (entry.isDirectory()) return true;
   if (entry.isSymbolicLink()) {
@@ -2459,6 +2571,7 @@ var SkillSource = /* @__PURE__ */ ((SkillSource2) => {
   SkillSource2["Global"] = "global";
   SkillSource2["ProjectClaude"] = "project-claude";
   SkillSource2["Project"] = "project";
+  SkillSource2["Builtin"] = "builtin";
   return SkillSource2;
 })(SkillSource || {});
 var MAX_NAME_LENGTH2 = 64;
@@ -2468,21 +2581,119 @@ var SkillManager = class {
   errors = [];
   paths;
   context;
+  /**
+   * Tracks which skills are currently "active" based on file operations.
+   * Skills with `paths` frontmatter are activated when matching files are accessed.
+   */
+  activeSkillNames = /* @__PURE__ */ new Set();
+  /**
+   * Maps alias names to original skill names for bundled skills.
+   */
+  aliasMap = /* @__PURE__ */ new Map();
   constructor(opts) {
     this.context = opts.context;
     this.paths = opts.context.paths;
   }
-  getSkills() {
-    return Array.from(this.skillsMap.values());
+  /**
+   * Get all loaded skills.
+   * @param options Filter options
+   * @returns Array of skill metadata
+   */
+  getSkills(options) {
+    let skills = Array.from(this.skillsMap.values());
+    if (options?.userInvocable !== void 0) {
+      skills = skills.filter(
+        (s) => (s.userInvocable ?? true) === options.userInvocable
+      );
+    }
+    if (options?.modelInvocable !== void 0) {
+      skills = skills.filter(
+        (s) => (s.modelInvocable ?? true) === options.modelInvocable
+      );
+    }
+    if (options?.activeOnly) {
+      skills = skills.filter((s) => this.activeSkillNames.has(s.name));
+    }
+    return skills;
   }
+  /**
+   * Get a specific skill by name.
+   * Automatically resolves aliases to the original skill.
+   * @param name Skill name or alias
+   * @returns Skill metadata or undefined if not found
+   */
   getSkill(name) {
-    return this.skillsMap.get(name);
+    const skill = this.skillsMap.get(name);
+    if (skill) return skill;
+    const originalName = this.aliasMap.get(name);
+    if (originalName) {
+      return this.skillsMap.get(originalName);
+    }
+    return void 0;
+  }
+  /**
+   * Check if a skill is active (has matching paths for current context).
+   * @param name Skill name
+   */
+  isSkillActive(name) {
+    return this.activeSkillNames.has(name);
+  }
+  /**
+   * Activate skills based on file paths.
+   * Skills with `paths` frontmatter that match the given paths will be activated.
+   * @param filePaths Array of file paths to check
+   * @returns Array of newly activated skill names
+   */
+  activateSkillsForPaths(filePaths) {
+    const newlyActivated = [];
+    const minimatch = __require("minimatch");
+    for (const [name, skill] of this.skillsMap) {
+      if (skill.paths && skill.paths.length > 0) {
+        const isMatch = skill.paths.some(
+          (pattern) => filePaths.some((filePath) => minimatch(filePath, pattern))
+        );
+        if (isMatch && !this.activeSkillNames.has(name)) {
+          this.activeSkillNames.add(name);
+          newlyActivated.push(name);
+        }
+      }
+    }
+    return newlyActivated;
+  }
+  /**
+   * Clear all active skill activations.
+   * Useful when switching contexts or projects.
+   */
+  clearActiveSkills() {
+    this.activeSkillNames.clear();
+  }
+  /**
+   * Get all skills that have path-based conditional activation.
+   * @returns Array of skills with paths defined
+   */
+  getConditionalSkills() {
+    return Array.from(this.skillsMap.values()).filter(
+      (s) => s.paths && s.paths.length > 0
+    );
   }
   getErrors() {
     return this.errors;
   }
-  async readSkillBody(skill) {
+  /**
+   * Read the body content of a skill.
+   * For file-based skills, reads from disk.
+   * For bundled skills, generates content via getPrompt.
+   */
+  async readSkillBody(skill, args = "") {
     try {
+      if (skill.path.startsWith("bundled://")) {
+        const bundledName = skill.path.replace("bundled://", "");
+        const bundledSkill = bundledSkillRegistry.get(bundledName);
+        if (!bundledSkill) {
+          throw new Error(`Bundled skill "${bundledName}" not found in registry`);
+        }
+        return await bundledSkill.getPrompt(args, this.context);
+      }
       const content = fs9.readFileSync(skill.path, "utf-8");
       const { body } = safeFrontMatter(content, skill.path);
       return body;
@@ -2491,9 +2702,26 @@ var SkillManager = class {
       throw new Error(`Failed to read skill ${skill.name}: ${message}`);
     }
   }
+  /**
+   * Get a bundled skill definition by name.
+   * @param name Bundled skill name
+   * @returns Bundled skill definition or undefined if not found
+   */
+  getBundledSkill(name) {
+    return bundledSkillRegistry.get(name);
+  }
+  /**
+   * Register a bundled skill programmatically.
+   * @param definition Bundled skill definition
+   */
+  registerBundledSkill(definition) {
+    bundledSkillRegistry.register(definition);
+    this.loadBuiltinSkills();
+  }
   async loadSkills() {
     this.skillsMap.clear();
     this.errors = [];
+    this.loadBuiltinSkills();
     const pluginSkills = await this.context.apply({
       hook: "skill",
       args: [],
@@ -2536,6 +2764,22 @@ var SkillManager = class {
     const projectDir = path9.join(this.paths.projectConfigDir, "skills");
     this.loadSkillsFromDirectory(projectDir, "project" /* Project */);
   }
+  /**
+   * Load builtin/bundled skills from the registry.
+   */
+  loadBuiltinSkills() {
+    this.aliasMap.clear();
+    const bundledSkills = bundledSkillRegistry.getAll(this.context);
+    for (const skill of bundledSkills) {
+      const metadata = bundledSkillToMetadata(skill, "builtin" /* Builtin */);
+      this.skillsMap.set(skill.name, metadata);
+      if (skill.aliases) {
+        for (const alias of skill.aliases) {
+          this.aliasMap.set(alias, skill.name);
+        }
+      }
+    }
+  }
   loadSkillsFromDirectory(skillsDir, source) {
     if (!fs9.existsSync(skillsDir)) {
       return;
@@ -2611,10 +2855,19 @@ var SkillManager = class {
         });
         return null;
       }
+      const allowedTools = this.parseStringArrayField(attributes.allowedTools);
+      const context = attributes.context === "inline" || attributes.context === "fork" ? attributes.context : void 0;
+      const paths = this.parseStringArrayField(attributes.paths);
       return {
         name: attributes.name,
         description: attributes.description,
-        path: skillPath
+        path: skillPath,
+        allowedTools,
+        context,
+        agent: attributes.agent,
+        paths,
+        userInvocable: attributes.userInvocable ?? true,
+        modelInvocable: attributes.modelInvocable ?? true
       };
     } catch (error) {
       this.errors.push({
@@ -2624,6 +2877,21 @@ var SkillManager = class {
       return null;
     }
   }
+  /**
+   * Parse a field that can be either a comma-separated string or an array of strings.
+   * @param value The value to parse
+   * @returns Array of strings or undefined if empty
+   */
+  parseStringArrayField(value) {
+    if (!value) return void 0;
+    if (Array.isArray(value)) {
+      return value.map((item) => item.trim()).filter((item) => item.length > 0);
+    }
+    if (typeof value === "string") {
+      return value.split(",").map((item) => item.trim()).filter((item) => item.length > 0);
+    }
+    return void 0;
+  }
   async addSkill(source, options = {}) {
     const {
       global: isGlobal = false,
@@ -4013,12 +4281,12 @@ var Engine = class {
     const systemPrompt = context.config.systemPrompt || "";
     let sessionHistory = void 0;
     if (options.sessionId) {
-      const { loadSessionMessages: loadSessionMessages2 } = await import("./session-QMS6OYG2.js");
+      const { loadSessionMessages: loadSessionMessages2 } = await import("./session-Z2XIKFVN.js");
       const logPath = context.paths.getSessionLogPath(sessionId);
       try {
         const existingMessages = loadSessionMessages2({ logPath });
         if (existingMessages.length > 0) {
-          const { History: History2 } = await import("./history-AGNMX5YW.js");
+          const { History: History2 } = await import("./history-WTZON3PI.js");
           sessionHistory = new History2({
             messages: existingMessages
           });
@@ -4220,6 +4488,9 @@ export {
   Usage,
   brainstormMode,
   builtinModes,
+  bundledSkillRegistry,
+  bundledSkillToMetadata,
+  createBundledSkill,
   createEngine,
   debugMode,
   defaultMode,
@@ -4231,6 +4502,7 @@ export {
   planMode,
   randomUUID,
   registerBuiltinModes,
+  registerBundledSkill,
   reviewMode
 };
 //# sourceMappingURL=index.js.map