octoflow-core 1.0.0

package/dist/capabilities/skill-injector.d.ts

@@ -0,0 +1,12 @@
+import type { ActionDefinition } from '../actions/types.js';
+import type { CapabilitySkill, CapabilityState } from './types.js';
+/**
+ * Merge skill actions into the base action list for a single invocation.
+ *
+ * - Evaluates each skill's condition against the current state.
+ * - Skips disabled skills and their actions entirely.
+ * - Uses a Map for O(n) deduplication; base actions win on name collision.
+ *
+ */
+export declare function resolveSkillActions(baseActions: ActionDefinition[], skills: CapabilitySkill[] | undefined, state: CapabilityState): Promise<ActionDefinition[]>;
+//# sourceMappingURL=skill-injector.d.ts.map

package/dist/capabilities/skill-injector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-injector.d.ts","sourceRoot":"","sources":["../../src/capabilities/skill-injector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAEnE;;;;;;;GAOG;AACH,wBAAsB,mBAAmB,CACvC,WAAW,EAAE,gBAAgB,EAAE,EAC/B,MAAM,EAAE,eAAe,EAAE,GAAG,SAAS,EACrC,KAAK,EAAE,eAAe,GACrB,OAAO,CAAC,gBAAgB,EAAE,CAAC,CAkB7B"}

package/dist/capabilities/skill-injector.js

@@ -0,0 +1,20 @@
+async function resolveSkillActions(baseActions, skills, state) {
+  if (!skills || skills.length === 0) {
+    return baseActions;
+  }
+  const merged = new Map(baseActions.map((action) => [action.name, action]));
+  for (const skill of skills) {
+    const enabled = await skill.condition?.(state) ?? true;
+    if (!enabled) continue;
+    for (const action of skill.actions) {
+      if (!merged.has(action.name)) {
+        merged.set(action.name, action);
+      }
+    }
+  }
+  return [...merged.values()];
+}
+export {
+  resolveSkillActions
+};
+//# sourceMappingURL=skill-injector.js.map

package/dist/capabilities/skill-injector.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/capabilities/skill-injector.ts"],
+  "sourcesContent": ["import type { ActionDefinition } from '../actions/types.js';\nimport type { CapabilitySkill, CapabilityState } from './types.js';\n\n/**\n * Merge skill actions into the base action list for a single invocation.\n *\n * - Evaluates each skill's condition against the current state.\n * - Skips disabled skills and their actions entirely.\n * - Uses a Map for O(n) deduplication; base actions win on name collision.\n *\n */\nexport async function resolveSkillActions(\n  baseActions: ActionDefinition[],\n  skills: CapabilitySkill[] | undefined,\n  state: CapabilityState\n): Promise<ActionDefinition[]> {\n  if (!skills || skills.length === 0) {\n    return baseActions;\n  }\n\n  const merged = new Map(baseActions.map((action) => [action.name, action]));\n\n  for (const skill of skills) {\n    const enabled = (await skill.condition?.(state)) ?? true;\n    if (!enabled) continue;\n    for (const action of skill.actions) {\n      if (!merged.has(action.name)) {\n        merged.set(action.name, action);\n      }\n    }\n  }\n\n  return [...merged.values()];\n}\n"],
+  "mappings": "AAWA,eAAsB,oBACpB,aACA,QACA,OAC6B;AAC7B,MAAI,CAAC,UAAU,OAAO,WAAW,GAAG;AAClC,WAAO;AAAA,EACT;AAEA,QAAM,SAAS,IAAI,IAAI,YAAY,IAAI,CAAC,WAAW,CAAC,OAAO,MAAM,MAAM,CAAC,CAAC;AAEzE,aAAW,SAAS,QAAQ;AAC1B,UAAM,UAAW,MAAM,MAAM,YAAY,KAAK,KAAM;AACpD,QAAI,CAAC,QAAS;AACd,eAAW,UAAU,MAAM,SAAS;AAClC,UAAI,CAAC,OAAO,IAAI,OAAO,IAAI,GAAG;AAC5B,eAAO,IAAI,OAAO,MAAM,MAAM;AAAA,MAChC;AAAA,IACF;AAAA,EACF;AAEA,SAAO,CAAC,GAAG,OAAO,OAAO,CAAC;AAC5B;",
+  "names": []
+}

package/dist/capabilities/skill-registry.d.ts

@@ -0,0 +1,42 @@
+import type { SkillDefinition } from './skill-types.js';
+import type { CapabilitySkill } from './types.js';
+/**
+ * Name-indexed runtime registry for {@link SkillDefinition}s.
+ *
+ * Mirrors ActionRegistry in shape and API surface. The bridge exposes this
+ * via `bridge.registry.registerSkill()` / `bridge.registry.listSkills()` etc. Plugins can also
+ * access it through PluginContext.registerSkill().
+ *
+ * @example
+ * ```ts
+ * const registry = new SkillRegistry();
+ * registry.register({ name: 'code-review', actions: [lintAction, testAction] });
+ * const skills = registry.toCapabilitySkills(); // for resolveSkillActions()
+ * ```
+ */
+export declare class SkillRegistry {
+    private readonly skills;
+    /** Register a skill. Overwrites any existing skill with the same name. */
+    register(skill: SkillDefinition): void;
+    /** Remove a skill by name. Returns `true` if it existed. */
+    unregister(name: string): boolean;
+    /** Look up a skill by name. Returns `undefined` if not found. */
+    get(name: string): SkillDefinition | undefined;
+    /** Returns `true` if a skill with this name is registered. */
+    has(name: string): boolean;
+    /** All registered skills in insertion order. */
+    all(): SkillDefinition[];
+    /** All registered skill names in insertion order. */
+    names(): string[];
+    /** Number of registered skills. */
+    size(): number;
+    /**
+     * Convert to the {@link CapabilitySkill} shape consumed by
+     * {@link resolveSkillActions}.
+     *
+     * Metadata (name, description, version, tags) is intentionally stripped —
+     * CapabilitySkill only needs actions and the condition gate.
+     */
+    toCapabilitySkills(): CapabilitySkill[];
+}
+//# sourceMappingURL=skill-registry.d.ts.map

package/dist/capabilities/skill-registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-registry.d.ts","sourceRoot":"","sources":["../../src/capabilities/skill-registry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACxD,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;;;;;;;GAaG;AACH,qBAAa,aAAa;IACxB,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAsC;IAE7D,0EAA0E;IAC1E,QAAQ,CAAC,KAAK,EAAE,eAAe,GAAG,IAAI;IAOtC,4DAA4D;IAC5D,UAAU,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAIjC,iEAAiE;IACjE,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,eAAe,GAAG,SAAS;IAI9C,8DAA8D;IAC9D,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO;IAI1B,gDAAgD;IAChD,GAAG,IAAI,eAAe,EAAE;IAIxB,qDAAqD;IACrD,KAAK,IAAI,MAAM,EAAE;IAIjB,mCAAmC;IACnC,IAAI,IAAI,MAAM;IAId;;;;;;OAMG;IACH,kBAAkB,IAAI,eAAe,EAAE;CAMxC"}

package/dist/capabilities/skill-registry.js

@@ -0,0 +1,51 @@
+class SkillRegistry {
+  skills = /* @__PURE__ */ new Map();
+  /** Register a skill. Overwrites any existing skill with the same name. */
+  register(skill) {
+    if (!skill.name) {
+      throw new Error("[octoflow] SkillRegistry: skill name is required");
+    }
+    this.skills.set(skill.name, skill);
+  }
+  /** Remove a skill by name. Returns `true` if it existed. */
+  unregister(name) {
+    return this.skills.delete(name);
+  }
+  /** Look up a skill by name. Returns `undefined` if not found. */
+  get(name) {
+    return this.skills.get(name);
+  }
+  /** Returns `true` if a skill with this name is registered. */
+  has(name) {
+    return this.skills.has(name);
+  }
+  /** All registered skills in insertion order. */
+  all() {
+    return [...this.skills.values()];
+  }
+  /** All registered skill names in insertion order. */
+  names() {
+    return [...this.skills.keys()];
+  }
+  /** Number of registered skills. */
+  size() {
+    return this.skills.size;
+  }
+  /**
+   * Convert to the {@link CapabilitySkill} shape consumed by
+   * {@link resolveSkillActions}.
+   *
+   * Metadata (name, description, version, tags) is intentionally stripped —
+   * CapabilitySkill only needs actions and the condition gate.
+   */
+  toCapabilitySkills() {
+    return this.all().map((s) => ({
+      actions: s.actions,
+      ...s.condition ? { condition: s.condition } : {}
+    }));
+  }
+}
+export {
+  SkillRegistry
+};
+//# sourceMappingURL=skill-registry.js.map

package/dist/capabilities/skill-registry.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/capabilities/skill-registry.ts"],
+  "sourcesContent": ["import type { SkillDefinition } from './skill-types.js';\nimport type { CapabilitySkill } from './types.js';\n\n/**\n * Name-indexed runtime registry for {@link SkillDefinition}s.\n *\n * Mirrors ActionRegistry in shape and API surface. The bridge exposes this\n * via `bridge.registry.registerSkill()` / `bridge.registry.listSkills()` etc. Plugins can also\n * access it through PluginContext.registerSkill().\n *\n * @example\n * ```ts\n * const registry = new SkillRegistry();\n * registry.register({ name: 'code-review', actions: [lintAction, testAction] });\n * const skills = registry.toCapabilitySkills(); // for resolveSkillActions()\n * ```\n */\nexport class SkillRegistry {\n  private readonly skills = new Map<string, SkillDefinition>();\n\n  /** Register a skill. Overwrites any existing skill with the same name. */\n  register(skill: SkillDefinition): void {\n    if (!skill.name) {\n      throw new Error('[octoflow] SkillRegistry: skill name is required');\n    }\n    this.skills.set(skill.name, skill);\n  }\n\n  /** Remove a skill by name. Returns `true` if it existed. */\n  unregister(name: string): boolean {\n    return this.skills.delete(name);\n  }\n\n  /** Look up a skill by name. Returns `undefined` if not found. */\n  get(name: string): SkillDefinition | undefined {\n    return this.skills.get(name);\n  }\n\n  /** Returns `true` if a skill with this name is registered. */\n  has(name: string): boolean {\n    return this.skills.has(name);\n  }\n\n  /** All registered skills in insertion order. */\n  all(): SkillDefinition[] {\n    return [...this.skills.values()];\n  }\n\n  /** All registered skill names in insertion order. */\n  names(): string[] {\n    return [...this.skills.keys()];\n  }\n\n  /** Number of registered skills. */\n  size(): number {\n    return this.skills.size;\n  }\n\n  /**\n   * Convert to the {@link CapabilitySkill} shape consumed by\n   * {@link resolveSkillActions}.\n   *\n   * Metadata (name, description, version, tags) is intentionally stripped \u2014\n   * CapabilitySkill only needs actions and the condition gate.\n   */\n  toCapabilitySkills(): CapabilitySkill[] {\n    return this.all().map((s) => ({\n      actions: s.actions,\n      ...(s.condition ? { condition: s.condition } : {}),\n    }));\n  }\n}\n"],
+  "mappings": "AAiBO,MAAM,cAAc;AAAA,EACR,SAAS,oBAAI,IAA6B;AAAA;AAAA,EAG3D,SAAS,OAA8B;AACrC,QAAI,CAAC,MAAM,MAAM;AACf,YAAM,IAAI,MAAM,kDAAkD;AAAA,IACpE;AACA,SAAK,OAAO,IAAI,MAAM,MAAM,KAAK;AAAA,EACnC;AAAA;AAAA,EAGA,WAAW,MAAuB;AAChC,WAAO,KAAK,OAAO,OAAO,IAAI;AAAA,EAChC;AAAA;AAAA,EAGA,IAAI,MAA2C;AAC7C,WAAO,KAAK,OAAO,IAAI,IAAI;AAAA,EAC7B;AAAA;AAAA,EAGA,IAAI,MAAuB;AACzB,WAAO,KAAK,OAAO,IAAI,IAAI;AAAA,EAC7B;AAAA;AAAA,EAGA,MAAyB;AACvB,WAAO,CAAC,GAAG,KAAK,OAAO,OAAO,CAAC;AAAA,EACjC;AAAA;AAAA,EAGA,QAAkB;AAChB,WAAO,CAAC,GAAG,KAAK,OAAO,KAAK,CAAC;AAAA,EAC/B;AAAA;AAAA,EAGA,OAAe;AACb,WAAO,KAAK,OAAO;AAAA,EACrB;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,EASA,qBAAwC;AACtC,WAAO,KAAK,IAAI,EAAE,IAAI,CAAC,OAAO;AAAA,MAC5B,SAAS,EAAE;AAAA,MACX,GAAI,EAAE,YAAY,EAAE,WAAW,EAAE,UAAU,IAAI,CAAC;AAAA,IAClD,EAAE;AAAA,EACJ;AACF;",
+  "names": []
+}

package/dist/capabilities/skill-types.d.ts

@@ -0,0 +1,50 @@
+import type { ActionDefinition } from '../actions/types.js';
+import type { BackendName } from '../domain/core-client.js';
+import type { CapabilityState } from './types.js';
+/**
+ * A named, versioned bundle of actions that can be registered with the
+ * bridge's SkillRegistry and delivered to any backend.
+ *
+ * Skills are the higher-level concept: they carry metadata (name, description,
+ * version, tags) and a condition gate, while CapabilitySkill is the leaner
+ * internal shape used by resolveSkillActions().
+ */
+export interface SkillDefinition {
+    /** Unique identifier — required for SkillRegistry keying and introspection. */
+    name: string;
+    /** Human-readable summary of what this skill enables. */
+    description?: string;
+    /** Semver-style version string for audit/debug purposes. */
+    version?: string;
+    /** Arbitrary tags for filtering or discovery. */
+    tags?: string[];
+    /** Actions contributed by this skill. */
+    actions: ActionDefinition[];
+    /**
+     * Per-invocation gate evaluated against the current CapabilityState.
+     * When omitted the skill is always active.
+     * Use the `backend` field of the state to restrict to specific backends.
+     */
+    condition?: (state: CapabilityState) => boolean | Promise<boolean>;
+}
+/** How a skill's actions are surfaced to a given backend. */
+export type SkillDeliveryStrategy = 'native' | 'mcp' | 'prompt-injection' | 'none';
+/** Result of {@link prepareSkillDelivery}. */
+export interface SkillDeliveryResult {
+    strategy: SkillDeliveryStrategy;
+    /** Actions resolved for this backend after condition evaluation. */
+    injectedActions: ActionDefinition[];
+    /** Non-empty only when strategy is `prompt-injection`. */
+    systemPromptSuffix?: string;
+}
+/**
+ * Coarse backend grouping used by prepareSkillDelivery() to decide the
+ * delivery strategy — mirrors the categorisation in tool-delivery.ts.
+ */
+export type SkillBackendFamily = 'api' | 'claude-code-cli' | 'other-cli' | 'custom';
+/**
+ * Classify a BackendName into one of four skill-delivery families.
+ *
+ */
+export declare function classifyBackendForSkills(backend: BackendName): SkillBackendFamily;
+//# sourceMappingURL=skill-types.d.ts.map

package/dist/capabilities/skill-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"skill-types.d.ts","sourceRoot":"","sources":["../../src/capabilities/skill-types.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,qBAAqB,CAAC;AAC5D,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,0BAA0B,CAAC;AAC5D,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,YAAY,CAAC;AAElD;;;;;;;GAOG;AACH,MAAM,WAAW,eAAe;IAC9B,+EAA+E;IAC/E,IAAI,EAAE,MAAM,CAAC;IACb,yDAAyD;IACzD,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,4DAA4D;IAC5D,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,iDAAiD;IACjD,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;IAChB,yCAAyC;IACzC,OAAO,EAAE,gBAAgB,EAAE,CAAC;IAC5B;;;;OAIG;IACH,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,eAAe,KAAK,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAC;CACpE;AAED,6DAA6D;AAC7D,MAAM,MAAM,qBAAqB,GAC7B,QAAQ,GACR,KAAK,GACL,kBAAkB,GAClB,MAAM,CAAC;AAEX,8CAA8C;AAC9C,MAAM,WAAW,mBAAmB;IAClC,QAAQ,EAAE,qBAAqB,CAAC;IAChC,oEAAoE;IACpE,eAAe,EAAE,gBAAgB,EAAE,CAAC;IACpC,0DAA0D;IAC1D,kBAAkB,CAAC,EAAE,MAAM,CAAC;CAC7B;AAED;;;GAGG;AACH,MAAM,MAAM,kBAAkB,GAC1B,KAAK,GACL,iBAAiB,GACjB,WAAW,GACX,QAAQ,CAAC;AAEb;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,WAAW,GACnB,kBAAkB,CAgBpB"}

package/dist/capabilities/skill-types.js

@@ -0,0 +1,14 @@
+function classifyBackendForSkills(backend) {
+  if (backend === "anthropic-api" || backend === "gemini-api" || backend === "openai-api" || backend === "ollama" || backend === "custom-api" || backend.startsWith("vercel-ai:")) {
+    return "api";
+  }
+  if (backend === "claude-code-cli") return "claude-code-cli";
+  if (backend === "codex-cli" || backend === "cursor-cli") {
+    return "other-cli";
+  }
+  return "custom";
+}
+export {
+  classifyBackendForSkills
+};
+//# sourceMappingURL=skill-types.js.map

package/dist/capabilities/skill-types.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/capabilities/skill-types.ts"],
+  "sourcesContent": ["import type { ActionDefinition } from '../actions/types.js';\nimport type { BackendName } from '../domain/core-client.js';\nimport type { CapabilityState } from './types.js';\n\n/**\n * A named, versioned bundle of actions that can be registered with the\n * bridge's SkillRegistry and delivered to any backend.\n *\n * Skills are the higher-level concept: they carry metadata (name, description,\n * version, tags) and a condition gate, while CapabilitySkill is the leaner\n * internal shape used by resolveSkillActions().\n */\nexport interface SkillDefinition {\n  /** Unique identifier \u2014 required for SkillRegistry keying and introspection. */\n  name: string;\n  /** Human-readable summary of what this skill enables. */\n  description?: string;\n  /** Semver-style version string for audit/debug purposes. */\n  version?: string;\n  /** Arbitrary tags for filtering or discovery. */\n  tags?: string[];\n  /** Actions contributed by this skill. */\n  actions: ActionDefinition[];\n  /**\n   * Per-invocation gate evaluated against the current CapabilityState.\n   * When omitted the skill is always active.\n   * Use the `backend` field of the state to restrict to specific backends.\n   */\n  condition?: (state: CapabilityState) => boolean | Promise<boolean>;\n}\n\n/** How a skill's actions are surfaced to a given backend. */\nexport type SkillDeliveryStrategy =\n  | 'native' // structured tool call (API backends + claude-code-cli)\n  | 'mcp' // mounted via MCP server config (reserved for future use)\n  | 'prompt-injection' // appended to system prompt (other CLIs, custom, a2a)\n  | 'none'; // no active actions after condition evaluation\n\n/** Result of {@link prepareSkillDelivery}. */\nexport interface SkillDeliveryResult {\n  strategy: SkillDeliveryStrategy;\n  /** Actions resolved for this backend after condition evaluation. */\n  injectedActions: ActionDefinition[];\n  /** Non-empty only when strategy is `prompt-injection`. */\n  systemPromptSuffix?: string;\n}\n\n/**\n * Coarse backend grouping used by prepareSkillDelivery() to decide the\n * delivery strategy \u2014 mirrors the categorisation in tool-delivery.ts.\n */\nexport type SkillBackendFamily =\n  | 'api'\n  | 'claude-code-cli'\n  | 'other-cli'\n  | 'custom';\n\n/**\n * Classify a BackendName into one of four skill-delivery families.\n *\n */\nexport function classifyBackendForSkills(\n  backend: BackendName\n): SkillBackendFamily {\n  if (\n    backend === 'anthropic-api' ||\n    backend === 'gemini-api' ||\n    backend === 'openai-api' ||\n    backend === 'ollama' ||\n    backend === 'custom-api' ||\n    backend.startsWith('vercel-ai:')\n  ) {\n    return 'api';\n  }\n  if (backend === 'claude-code-cli') return 'claude-code-cli';\n  if (backend === 'codex-cli' || backend === 'cursor-cli') {\n    return 'other-cli';\n  }\n  return 'custom';\n}\n"],
+  "mappings": "AA6DO,SAAS,yBACd,SACoB;AACpB,MACE,YAAY,mBACZ,YAAY,gBACZ,YAAY,gBACZ,YAAY,YACZ,YAAY,gBACZ,QAAQ,WAAW,YAAY,GAC/B;AACA,WAAO;AAAA,EACT;AACA,MAAI,YAAY,kBAAmB,QAAO;AAC1C,MAAI,YAAY,eAAe,YAAY,cAAc;AACvD,WAAO;AAAA,EACT;AACA,SAAO;AACT;",
+  "names": []
+}

package/dist/capabilities/skills/activator.d.ts

@@ -0,0 +1,2 @@
+export { activateSkill, renderSkillBody } from 'octoflow-skill-runner';
+//# sourceMappingURL=activator.d.ts.map

package/dist/capabilities/skills/activator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"activator.d.ts","sourceRoot":"","sources":["../../../src/capabilities/skills/activator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,eAAe,EAAE,MAAM,uBAAuB,CAAC"}

package/dist/capabilities/skills/activator.js

@@ -0,0 +1,6 @@
+import { activateSkill, renderSkillBody } from "octoflow-skill-runner";
+export {
+  activateSkill,
+  renderSkillBody
+};
+//# sourceMappingURL=activator.js.map

package/dist/capabilities/skills/activator.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/skills/activator.ts"],
+  "sourcesContent": ["export { activateSkill, renderSkillBody } from 'octoflow-skill-runner';\n"],
+  "mappings": "AAAA,SAAS,eAAe,uBAAuB;",
+  "names": []
+}

package/dist/capabilities/skills/bundle-loader.d.ts

@@ -0,0 +1,2 @@
+export { loadSkillBundle, loadSkillBundles, loadSkillPath, loadSkillPaths, type SkillBundleLoaderOptions, type SkillBundleMetadata, } from 'octoflow-skill-runner';
+//# sourceMappingURL=bundle-loader.d.ts.map

package/dist/capabilities/skills/bundle-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bundle-loader.d.ts","sourceRoot":"","sources":["../../../src/capabilities/skills/bundle-loader.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,gBAAgB,EAChB,aAAa,EACb,cAAc,EACd,KAAK,wBAAwB,EAC7B,KAAK,mBAAmB,GACzB,MAAM,uBAAuB,CAAC"}

package/dist/capabilities/skills/bundle-loader.js

@@ -0,0 +1,13 @@
+import {
+  loadSkillBundle,
+  loadSkillBundles,
+  loadSkillPath,
+  loadSkillPaths
+} from "octoflow-skill-runner";
+export {
+  loadSkillBundle,
+  loadSkillBundles,
+  loadSkillPath,
+  loadSkillPaths
+};
+//# sourceMappingURL=bundle-loader.js.map

package/dist/capabilities/skills/bundle-loader.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/skills/bundle-loader.ts"],
+  "sourcesContent": ["export {\n  loadSkillBundle,\n  loadSkillBundles,\n  loadSkillPath,\n  loadSkillPaths,\n  type SkillBundleLoaderOptions,\n  type SkillBundleMetadata,\n} from 'octoflow-skill-runner';\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,EACA;AAAA,OAGK;",
+  "names": []
+}

package/dist/capabilities/skills/catalog.d.ts

@@ -0,0 +1,2 @@
+export { AGENT_SKILLS_CATALOG_KEY, buildSkillCatalog, buildSkillCatalogSection, type BuildSkillCatalogSectionOptions, type SkillCatalogSection, } from 'octoflow-skill-runner';
+//# sourceMappingURL=catalog.d.ts.map

package/dist/capabilities/skills/catalog.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"catalog.d.ts","sourceRoot":"","sources":["../../../src/capabilities/skills/catalog.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EACxB,iBAAiB,EACjB,wBAAwB,EACxB,KAAK,+BAA+B,EACpC,KAAK,mBAAmB,GACzB,MAAM,uBAAuB,CAAC"}

package/dist/capabilities/skills/catalog.js

@@ -0,0 +1,11 @@
+import {
+  AGENT_SKILLS_CATALOG_KEY,
+  buildSkillCatalog,
+  buildSkillCatalogSection
+} from "octoflow-skill-runner";
+export {
+  AGENT_SKILLS_CATALOG_KEY,
+  buildSkillCatalog,
+  buildSkillCatalogSection
+};
+//# sourceMappingURL=catalog.js.map

package/dist/capabilities/skills/catalog.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../../src/capabilities/skills/catalog.ts"],
+  "sourcesContent": ["export {\n  AGENT_SKILLS_CATALOG_KEY,\n  buildSkillCatalog,\n  buildSkillCatalogSection,\n  type BuildSkillCatalogSectionOptions,\n  type SkillCatalogSection,\n} from 'octoflow-skill-runner';\n"],
+  "mappings": "AAAA;AAAA,EACE;AAAA,EACA;AAAA,EACA;AAAA,OAGK;",
+  "names": []
+}

package/dist/capabilities/skills/discovery.d.ts

@@ -0,0 +1,131 @@
+import type { LocalContextVendorId } from '../../runtime/sessions/local-context-types.js';
+import type { LocalContextSource } from '../local-context/types.js';
+import { type SkillBundleLoaderOptions } from './bundle-loader.js';
+import type { AgentSkillMetadata, FrontmatterParser } from './types.js';
+/**
+ * Origin tag carried on each discovered skill — surfaced for telemetry,
+ * UI ("which agent does this skill belong to?"), and conflict reporting.
+ */
+export interface DiscoveredSkillOrigin {
+    /**
+     * Vendor descriptor that owned the path:
+     *   - one of `LocalContextVendorId` for tool-managed dirs
+     *   - `'extra'` for caller-supplied paths in `extraPaths`
+     */
+    source: LocalContextVendorId | 'extra';
+    /** Absolute path to the skill bundle directory. */
+    path: string;
+    scope: 'project' | 'user' | 'custom';
+}
+export interface DiscoveredSkill {
+    meta: AgentSkillMetadata;
+    origin: DiscoveredSkillOrigin;
+}
+/**
+ * Configures the parent-directory walk that picks up `skills/` (or any
+ * other named) folders relative to the running code.
+ *
+ * Use case: a template, plugin, or sub-app ships its own bundles under
+ * `<code>/skills/*` and wants them auto-discovered without hardcoding
+ * the absolute path. Pass `from: import.meta.url` (or `__dirname`).
+ */
+export interface RelativePathDiscovery {
+    /**
+     * Starting directory or file. Accepts:
+     *   - an absolute or relative directory
+     *   - an absolute or relative file path (uses its `dirname`)
+     *   - a `file://` URL (the value of `import.meta.url`)
+     * Default: `process.cwd()`.
+     */
+    from?: string;
+    /** Folder names to look for at each level. Default: `['skills']`. */
+    dirNames?: string[];
+    /** How many parent levels to walk up from `from`. Default: `6`. */
+    maxDepth?: number;
+    /**
+     * Stop walking once this absolute directory has been visited (inclusive).
+     * Default: no extra stop — the walk terminates at the filesystem root or
+     * when `maxDepth` is exhausted.
+     */
+    stopAt?: string;
+}
+export interface DiscoverLocalSkillsOptions {
+    /** Override CWD; defaults to `process.cwd()`. */
+    cwd?: string;
+    /** Override `$HOME`; defaults to `os.homedir()`. */
+    home?: string;
+    /** Restrict discovery to specific tool/agent vendors. */
+    vendors?: LocalContextVendorId[];
+    /** Exclude specific vendors. */
+    excludeVendors?: LocalContextVendorId[];
+    /** Filter to scopes; defaults `['project', 'user']`. */
+    scopes?: Array<'project' | 'user'>;
+    /**
+     * Filter the final result to skills whose `name` matches one of these.
+     * Useful for `addByName` flows. Names not found are returned in
+     * `result.missingNames` rather than throwing — caller decides.
+     */
+    names?: string[];
+    /**
+     * Extra filesystem paths to also scan. Each entry may be:
+     *   - a single skill bundle directory (containing `SKILL.md`)
+     *   - a parent directory containing many skill bundles
+     * Project/user discovery still runs unless disabled by setting
+     * `vendors: []` and `excludeVendors: []` together.
+     */
+    extraPaths?: string[];
+    /** Disable the built-in vendor scan (only `extraPaths` and `walkUp` paths will be searched). */
+    skipVendorScan?: boolean;
+    /**
+     * Walk parent directories from a starting location looking for any
+     * folder whose name matches `dirNames` (default `['skills']`), and
+     * scan each match the same way as `extraPaths`.
+     *
+     * Pass `walkUp: true` to use defaults (`from = process.cwd()`,
+     * `dirNames = ['skills']`, `maxDepth = 6`).
+     */
+    walkUp?: boolean | RelativePathDiscovery;
+    parser?: FrontmatterParser;
+    onWarn?: SkillBundleLoaderOptions['onWarn'];
+    onValidation?: SkillBundleLoaderOptions['onValidation'];
+}
+export interface DiscoverLocalSkillsResult {
+    /** Discovered + filtered skills (deduped on `name`, project > user > custom). */
+    skills: DiscoveredSkill[];
+    /** Names listed in `opts.names` that did not match any discovered skill. */
+    missingNames: string[];
+    /** Tool-vendor sources that contributed skills (mirrors LocalContextResult.sources). */
+    sources: LocalContextSource[];
+    /** Non-fatal issues — same shape as `LocalContextResult.warnings`. */
+    warnings: string[];
+}
+/**
+ * One-stop skill discovery across every well-known location octoflow
+ * already knows about (Claude Code, Cursor, Codex, Gemini, Cline, Roo,
+ * Junie, Continue, Goose, Amp, Crush, Kilo Code, Qwen Code, Trae, Windsurf,
+ * Zed, OpenCode, Copilot, VSCode, Claude Desktop) plus any caller-supplied
+ * `extraPaths`.
+ *
+ * - Vendor scan reuses {@link discoverLocalContext} with `mcp: false`.
+ * - `extraPaths` accepts both bundle dirs and parent dirs of bundles.
+ * - `names` filters the final result; missing names are reported, not thrown.
+ *
+ * The output ships with an {@link DiscoveredSkillOrigin} tag per skill so
+ * callers can distinguish "claude-code at user scope" from "extra path".
+ *
+ * @example
+ * ```ts
+ * import { discoverLocalSkills } from 'octoflow-core';
+ *
+ * const { skills, missingNames } = await discoverLocalSkills({
+ *   names: ['grill-me', 'octocode-news'],
+ *   extraPaths: ['./vendor/skills'],
+ * });
+ *
+ * const bridge = await createBridge({
+ *   agentSkills: { bundles: skills.map((s) => s.meta) },
+ * });
+ * ```
+ */
+export declare function discoverLocalSkills(options?: DiscoverLocalSkillsOptions): Promise<DiscoverLocalSkillsResult>;
+//# sourceMappingURL=discovery.d.ts.map

package/dist/capabilities/skills/discovery.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"discovery.d.ts","sourceRoot":"","sources":["../../../src/capabilities/skills/discovery.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,+CAA+C,CAAC;AAE1F,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,2BAA2B,CAAC;AACpE,OAAO,EAEL,KAAK,wBAAwB,EAC9B,MAAM,oBAAoB,CAAC;AAG5B,OAAO,KAAK,EAAE,kBAAkB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAExE;;;GAGG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;OAIG;IACH,MAAM,EAAE,oBAAoB,GAAG,OAAO,CAAC;IACvC,mDAAmD;IACnD,IAAI,EAAE,MAAM,CAAC;IACb,KAAK,EAAE,SAAS,GAAG,MAAM,GAAG,QAAQ,CAAC;CACtC;AAED,MAAM,WAAW,eAAe;IAC9B,IAAI,EAAE,kBAAkB,CAAC;IACzB,MAAM,EAAE,qBAAqB,CAAC;CAC/B;AAED;;;;;;;GAOG;AACH,MAAM,WAAW,qBAAqB;IACpC;;;;;;OAMG;IACH,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,qEAAqE;IACrE,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,mEAAmE;IACnE,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB;;;;OAIG;IACH,MAAM,CAAC,EAAE,MAAM,CAAC;CACjB;AAED,MAAM,WAAW,0BAA0B;IACzC,iDAAiD;IACjD,GAAG,CAAC,EAAE,MAAM,CAAC;IACb,oDAAoD;IACpD,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,yDAAyD;IACzD,OAAO,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACjC,gCAAgC;IAChC,cAAc,CAAC,EAAE,oBAAoB,EAAE,CAAC;IACxC,wDAAwD;IACxD,MAAM,CAAC,EAAE,KAAK,CAAC,SAAS,GAAG,MAAM,CAAC,CAAC;IACnC;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB;;;;;;OAMG;IACH,UAAU,CAAC,EAAE,MAAM,EAAE,CAAC;IACtB,gGAAgG;IAChG,cAAc,CAAC,EAAE,OAAO,CAAC;IACzB;;;;;;;OAOG;IACH,MAAM,CAAC,EAAE,OAAO,GAAG,qBAAqB,CAAC;IACzC,MAAM,CAAC,EAAE,iBAAiB,CAAC;IAC3B,MAAM,CAAC,EAAE,wBAAwB,CAAC,QAAQ,CAAC,CAAC;IAC5C,YAAY,CAAC,EAAE,wBAAwB,CAAC,cAAc,CAAC,CAAC;CACzD;AAED,MAAM,WAAW,yBAAyB;IACxC,iFAAiF;IACjF,MAAM,EAAE,eAAe,EAAE,CAAC;IAC1B,4EAA4E;IAC5E,YAAY,EAAE,MAAM,EAAE,CAAC;IACvB,wFAAwF;IACxF,OAAO,EAAE,kBAAkB,EAAE,CAAC;IAC9B,sEAAsE;IACtE,QAAQ,EAAE,MAAM,EAAE,CAAC;CACpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,wBAAsB,mBAAmB,CACvC,OAAO,GAAE,0BAA+B,GACvC,OAAO,CAAC,yBAAyB,CAAC,CAwEpC"}

package/dist/capabilities/skills/discovery.js

@@ -0,0 +1,143 @@
+import { promises as fs } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { discoverLocalContext } from "../local-context/index.js";
+import {
+  loadSkillBundle
+} from "./bundle-loader.js";
+import { parseFrontmatter } from "./frontmatter.js";
+import { scanSkillDirs } from "./scanner.js";
+async function discoverLocalSkills(options = {}) {
+  const cwd = options.cwd ?? process.cwd();
+  const parser = options.parser ?? parseFrontmatter;
+  const warnings = [];
+  const sources = [];
+  const collected = /* @__PURE__ */ new Map();
+  if (!options.skipVendorScan) {
+    const local = await discoverLocalContext({
+      mcp: false,
+      skills: true,
+      cwd: options.cwd,
+      home: options.home,
+      vendors: options.vendors,
+      excludeVendors: options.excludeVendors,
+      scopes: options.scopes
+    });
+    sources.push(...local.sources);
+    warnings.push(...local.warnings);
+    for (const meta of local.skills) {
+      const vendor = meta._source?.vendor;
+      const scope = meta._source?.scope ?? meta.scope;
+      const origin = {
+        source: vendor ?? "extra",
+        path: meta.baseDir,
+        scope: scope === "admin" ? "custom" : scope
+      };
+      if (!collected.has(meta.name)) {
+        collected.set(meta.name, { meta, origin });
+      }
+    }
+  }
+  const candidatePaths = [];
+  for (const extra of options.extraPaths ?? []) {
+    candidatePaths.push(path.resolve(cwd, extra));
+  }
+  if (options.walkUp) {
+    const spec = options.walkUp === true ? {} : options.walkUp;
+    candidatePaths.push(...await expandWalkUp(spec, cwd));
+  }
+  for (const abs of candidatePaths) {
+    const found2 = await loadFromExtraPath(abs, {
+      parser,
+      onWarn: options.onWarn,
+      onValidation: options.onValidation
+    });
+    for (const meta of found2) {
+      const origin = {
+        source: "extra",
+        path: meta.baseDir,
+        scope: "custom"
+      };
+      if (!collected.has(meta.name)) {
+        collected.set(meta.name, { meta, origin });
+      }
+    }
+  }
+  const allSkills = [...collected.values()];
+  if (!options.names || options.names.length === 0) {
+    return { skills: allSkills, missingNames: [], sources, warnings };
+  }
+  const wanted = new Set(options.names);
+  const found = allSkills.filter((s) => wanted.has(s.meta.name));
+  const foundNames = new Set(found.map((s) => s.meta.name));
+  const missingNames = options.names.filter((n) => !foundNames.has(n));
+  return { skills: found, missingNames, sources, warnings };
+}
+async function loadFromExtraPath(abs, opts) {
+  let stat;
+  try {
+    stat = await fs.stat(abs);
+  } catch {
+    return [];
+  }
+  if (!stat.isDirectory()) return [];
+  const direct = path.join(abs, "SKILL.md");
+  try {
+    await fs.access(direct);
+    const meta = await loadSkillBundle(abs, {
+      parser: opts.parser,
+      onWarn: opts.onWarn,
+      onValidation: opts.onValidation,
+      strict: false
+    });
+    return [meta];
+  } catch {
+  }
+  return scanSkillDirs({
+    basePath: abs,
+    scope: "custom",
+    vendorPaths: ["."],
+    parser: opts.parser,
+    onWarn: opts.onWarn,
+    onValidation: opts.onValidation
+  });
+}
+async function expandWalkUp(spec, cwd) {
+  const fromRaw = spec.from ?? cwd;
+  let start;
+  if (fromRaw.startsWith("file://")) {
+    start = fileURLToPath(fromRaw);
+  } else {
+    start = path.resolve(cwd, fromRaw);
+  }
+  try {
+    const stat = await fs.stat(start);
+    if (!stat.isDirectory()) start = path.dirname(start);
+  } catch {
+    start = path.dirname(start);
+  }
+  const dirNames = spec.dirNames ?? ["skills"];
+  const maxDepth = spec.maxDepth ?? 6;
+  const stopAt = spec.stopAt ? path.resolve(spec.stopAt) : null;
+  const matched = [];
+  let cur = start;
+  for (let depth = 0; depth <= maxDepth; depth++) {
+    for (const name of dirNames) {
+      const candidate = path.join(cur, name);
+      try {
+        const s = await fs.stat(candidate);
+        if (s.isDirectory()) matched.push(candidate);
+      } catch {
+      }
+    }
+    if (stopAt && cur === stopAt) break;
+    const parent = path.dirname(cur);
+    if (parent === cur) break;
+    cur = parent;
+  }
+  return matched;
+}
+export {
+  discoverLocalSkills
+};
+//# sourceMappingURL=discovery.js.map