oricore 1.5.0 → 1.5.1

package/dist/{chunk-OYWDQD3F.js → chunk-XBRIUBK5.js}

@@ -2,7 +2,7 @@ import {
   History,
   Usage,
   randomUUID
-} from "./chunk-4QYFQSAC.js";
+} from "./chunk-MZNH54NB.js";
 
 // src/session/session.ts
 import fs2 from "fs";
@@ -317,4 +317,4 @@ export {
   filterMessages,
   loadSessionMessages
 };
-//# sourceMappingURL=chunk-OYWDQD3F.js.map
+//# sourceMappingURL=chunk-XBRIUBK5.js.map

package/dist/history-FS6CASR6.js

@@ -0,0 +1,8 @@
+import {
+  History
+} from "./chunk-MZNH54NB.js";
+import "./chunk-D5X6YFSK.js";
+export {
+  History
+};
+//# sourceMappingURL=history-FS6CASR6.js.map

package/dist/index.cjs

@@ -32813,80 +32813,6 @@ var init_read = __esm({
   }
 });
 
-// src/tools/tools/skill.ts
-function renderAvailableSkills(skills) {
-  return skills.map(
-    (skill) => `<skill>
-<name>${skill.name}</name>
-<description>${skill.description}</description>
-</skill>`
-  ).join("\n");
-}
-function generateDescription(skillManager) {
-  const skills = skillManager.getSkills();
-  return `Execute a skill within the main conversation
-<skills_instructions>
-When users ask you to perform tasks, check if any of the available skills below match the task. If a skill matches, use this tool to invoke it. Skills provide specialized knowledge and procedures for specific tasks.
-</skills_instructions>
-<available_skills>
-${renderAvailableSkills(skills)}
-</available_skills>`;
-}
-function createSkillTool(opts) {
-  return createTool({
-    name: "skill",
-    description: generateDescription(opts.skillManager),
-    parameters: import_zod9.z.object({
-      skill: import_zod9.z.string().describe("The skill name to execute")
-    }),
-    getDescription: ({ params }) => {
-      return params.skill;
-    },
-    async execute({ skill }) {
-      const trimmed = skill.trim();
-      const skillName = trimmed.startsWith("/") ? trimmed.substring(1) : trimmed;
-      const foundSkill = opts.skillManager.getSkill(skillName);
-      if (!foundSkill) {
-        return {
-          isError: true,
-          llmContent: `Skill "${skillName}" not found`
-        };
-      }
-      const body = await opts.skillManager.readSkillBody(foundSkill);
-      const baseDir = import_pathe13.default.dirname(foundSkill.path);
-      const messages = [
-        {
-          type: "text",
-          text: `<command-message>${skillName} is running\u2026</command-message>
-<command-name>${skillName}</command-name>`
-        },
-        {
-          type: "text",
-          text: `Base directory for this skill: ${baseDir}
-
-${body}`,
-          isMeta: true
-        }
-      ];
-      return {
-        llmContent: safeStringify(messages),
-        returnDisplay: `Loaded skill: ${foundSkill.name}`
-      };
-    },
-    approval: { category: "read" }
-  });
-}
-var import_pathe13, import_zod9;
-var init_skill = __esm({
-  "src/tools/tools/skill.ts"() {
-    "use strict";
-    import_pathe13 = __toESM(require("pathe"), 1);
-    import_zod9 = require("zod");
-    init_tool();
-    init_safeStringify();
-  }
-});
-
 // src/tools/tools/task.ts
 function createTaskTool(opts) {
   const { signal, sessionId } = opts;
@@ -32953,11 +32879,11 @@ Since the user is greeting, use the greeting-responder agent to respond with a f
 assistant: "I'm going to use the ${"task" /* TASK */} tool to launch the with the greeting-responder agent"
 </example>
       `,
-    parameters: import_zod10.z.object({
-      description: import_zod10.z.string().describe("A short (3-5 word) description of task"),
-      prompt: import_zod10.z.string().describe("The task for the agent to perform"),
-      subagent_type: import_zod10.z.string().describe("The type of specialized agent to use for this task"),
-      resume: import_zod10.z.string().optional().describe(
+    parameters: import_zod9.z.object({
+      description: import_zod9.z.string().describe("A short (3-5 word) description of task"),
+      prompt: import_zod9.z.string().describe("The task for the agent to perform"),
+      subagent_type: import_zod9.z.string().describe("The type of specialized agent to use for this task"),
+      resume: import_zod9.z.string().optional().describe(
         "Optional agent ID to resume from. If provided, the agent will continue from the previous execution transcript."
       )
     }),
@@ -33128,17 +33054,135 @@ Agent ID: ${result.agentId}`,
     approval: { category: "read" }
   });
 }
-var import_zod10;
+var import_zod9;
 var init_task = __esm({
   "src/tools/tools/task.ts"() {
     "use strict";
-    import_zod10 = require("zod");
+    import_zod9 = require("zod");
     init_constants();
     init_tool();
     init_randomUUID();
   }
 });
 
+// src/tools/tools/skill.ts
+function renderAvailableSkills(skills) {
+  return skills.filter((skill) => skill.modelInvocable !== false).map(
+    (skill) => `<skill>
+<name>${skill.name}</name>
+<description>${skill.description}</description>
+</skill>`
+  ).join("\n");
+}
+function generateDescription(skillManager) {
+  const skills = skillManager.getSkills({ modelInvocable: true });
+  return `Execute a skill within the main conversation
+<skills_instructions>
+When users ask you to perform tasks, check if any of the available skills below match the task. If a skill matches, use this tool to invoke it. Skills provide specialized knowledge and procedures for specific tasks.
+</skills_instructions>
+<available_skills>
+${renderAvailableSkills(skills)}
+</available_skills>`;
+}
+function createSkillTool(opts) {
+  const { skillManager, context, tools, sessionId, signal } = opts;
+  return createTool({
+    name: "skill",
+    description: generateDescription(skillManager),
+    parameters: import_zod10.z.object({
+      skill: import_zod10.z.string().describe("The skill name to execute"),
+      args: import_zod10.z.string().optional().describe("Optional arguments to pass to the skill")
+    }),
+    getDescription: ({ params }) => {
+      return params.args ? `${params.skill} ${params.args}` : params.skill;
+    },
+    async execute({ skill, args }) {
+      const trimmed = skill.trim();
+      const skillName = trimmed.startsWith("/") ? trimmed.substring(1) : trimmed;
+      const foundSkill = skillManager.getSkill(skillName);
+      if (!foundSkill) {
+        return {
+          isError: true,
+          llmContent: `Skill "${skillName}" not found`
+        };
+      }
+      if (foundSkill.modelInvocable === false) {
+        return {
+          isError: true,
+          llmContent: `Skill "${skillName}" cannot be invoked by the model`
+        };
+      }
+      const skillArgs = args || "";
+      const body = await skillManager.readSkillBody(foundSkill, skillArgs);
+      const baseDir = import_pathe13.default.dirname(foundSkill.path);
+      if (foundSkill.context === "fork") {
+        if (!context.agentManager) {
+          return {
+            isError: true,
+            llmContent: `Skill "${skillName}" requires fork execution but agent manager is not available`
+          };
+        }
+        const allowedTools = foundSkill.allowedTools;
+        const filteredTools = allowedTools ? tools.filter(
+          (t) => t.name !== "skill" && allowedTools.some(
+            (allowed) => allowed.toLowerCase() === t.name.toLowerCase()
+          )
+        ) : tools.filter((t) => t.name !== "skill");
+        const taskTool = createTaskTool({
+          context,
+          tools: filteredTools,
+          sessionId,
+          signal
+        });
+        const agentType = foundSkill.agent || "general-purpose";
+        const prompt = `Base directory for this skill: ${baseDir}
+
+${body}`;
+        const toolCallId = `skill-${skillName}-${randomUUID()}`;
+        return taskTool.execute(
+          {
+            description: `Execute skill: ${skillName}`,
+            prompt,
+            subagent_type: agentType
+          },
+          toolCallId
+        );
+      }
+      const messages = [
+        {
+          type: "text",
+          text: `<command-message>${skillName} is running\u2026</command-message>
+<command-name>${skillName}</command-name>`
+        },
+        {
+          type: "text",
+          text: `Base directory for this skill: ${baseDir}
+
+${body}`,
+          isMeta: true
+        }
+      ];
+      return {
+        llmContent: safeStringify(messages),
+        returnDisplay: `Loaded skill: ${foundSkill.name}`
+      };
+    },
+    approval: { category: "read" }
+  });
+}
+var import_pathe13, import_zod10;
+var init_skill = __esm({
+  "src/tools/tools/skill.ts"() {
+    "use strict";
+    import_pathe13 = __toESM(require("pathe"), 1);
+    import_zod10 = require("zod");
+    init_tool();
+    init_safeStringify();
+    init_task();
+    init_randomUUID();
+  }
+});
+
 // src/tools/tools/todo.ts
 async function loadTodosFromFile(filePath) {
   if (!import_fs13.default.existsSync(filePath)) return [];
@@ -33481,8 +33525,7 @@ async function resolveTools(opts) {
     createLSTool({ cwd }),
     createGlobTool({ cwd }),
     createGrepTool({ cwd }),
-    createFetchTool({ model, fetch: opts.context.fetch }),
-    ...hasSkills ? [createSkillTool({ skillManager: opts.context.skillManager })] : []
+    createFetchTool({ model, fetch: opts.context.fetch })
   ];
   const askUserQuestionTools = opts.askUserQuestion ? [createAskUserQuestionTool()] : [];
   const writeTools = opts.write ? [
@@ -33510,7 +33553,7 @@ async function resolveTools(opts) {
     })
   ] : [];
   const mcpTools = await getMcpTools(opts.context);
-  const allTools = [
+  let allTools = [
     ...readonlyTools,
     ...askUserQuestionTools,
     ...writeTools,
@@ -33518,6 +33561,16 @@ async function resolveTools(opts) {
     ...backgroundTools,
     ...mcpTools
   ];
+  if (hasSkills) {
+    const skillTool = createSkillTool({
+      skillManager: opts.context.skillManager,
+      context: opts.context,
+      tools: allTools,
+      sessionId: opts.sessionId,
+      signal: opts.signal
+    });
+    allTools = [...allTools, skillTool];
+  }
   let availableTools = allTools;
   try {
     availableTools = await opts.context.apply({
@@ -34047,6 +34100,9 @@ __export(index_exports, {
   Usage: () => Usage,
   brainstormMode: () => brainstormMode,
   builtinModes: () => builtinModes,
+  bundledSkillRegistry: () => bundledSkillRegistry,
+  bundledSkillToMetadata: () => bundledSkillToMetadata,
+  createBundledSkill: () => createBundledSkill,
   createEngine: () => createEngine,
   debugMode: () => debugMode,
   defaultMode: () => defaultMode,
@@ -34058,6 +34114,7 @@ __export(index_exports, {
   planMode: () => planMode,
   randomUUID: () => randomUUID,
   registerBuiltinModes: () => registerBuiltinModes,
+  registerBundledSkill: () => registerBundledSkill,
   reviewMode: () => reviewMode
 });
 module.exports = __toCommonJS(index_exports);
@@ -36520,6 +36577,116 @@ var import_fs23 = __toESM(require("fs"), 1);
 var import_os9 = __toESM(require("os"), 1);
 var import_pathe26 = __toESM(require("pathe"), 1);
 init_plugin();
+
+// 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()) {
@@ -36536,6 +36703,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;
@@ -36545,21 +36713,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 = import_fs23.default.readFileSync(skill.path, "utf-8");
       const { body } = safeFrontMatter(content, skill.path);
       return body;
@@ -36568,9 +36834,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: [],
@@ -36613,6 +36896,22 @@ var SkillManager = class {
     const projectDir = import_pathe26.default.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 (!import_fs23.default.existsSync(skillsDir)) {
       return;
@@ -36688,10 +36987,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({
@@ -36701,6 +37009,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,
@@ -38313,6 +38636,9 @@ var ENGINE_VERSION = "1.0.0";
   Usage,
   brainstormMode,
   builtinModes,
+  bundledSkillRegistry,
+  bundledSkillToMetadata,
+  createBundledSkill,
   createEngine,
   debugMode,
   defaultMode,
@@ -38324,6 +38650,7 @@ var ENGINE_VERSION = "1.0.0";
   planMode,
   randomUUID,
   registerBuiltinModes,
+  registerBundledSkill,
   reviewMode
 });
 /*! Bundled license information: