mirror of
https://github.com/openai/codex.git
synced 2026-11-19 22:30:42 +00:00
## What changed - Define and export skill metadata, policy, dependency, interface, and configuration rule types from `codex-skills`. - Update core, plugin, and extension consumers to use the shared models while retaining compatibility re-exports from `codex-core-skills`. - Share product-restriction handling between host and environment skill metadata. ## Testing - Add unit coverage for default and explicit implicit-invocation and product policies. GitOrigin-RevId: 9093469f8fff8e2d902dc9781235f64709827a87
175 lines
5.6 KiB
Rust
175 lines
5.6 KiB
Rust
use std::collections::HashMap;
|
|
use std::collections::HashSet;
|
|
use std::fmt;
|
|
use std::io;
|
|
use std::sync::Arc;
|
|
|
|
use codex_exec_server::ExecutorFileSystem;
|
|
use codex_exec_server::LOCAL_FS;
|
|
use codex_protocol::protocol::Product;
|
|
pub use codex_skills::SkillDependencies;
|
|
pub use codex_skills::SkillInterface;
|
|
pub use codex_skills::SkillMetadata;
|
|
pub use codex_skills::SkillPolicy;
|
|
pub use codex_skills::SkillToolDependency;
|
|
use codex_utils_absolute_path::AbsolutePathBuf;
|
|
use codex_utils_path_uri::PathUri;
|
|
|
|
#[derive(Debug, Clone, PartialEq, Eq)]
|
|
pub struct SkillError {
|
|
pub path: AbsolutePathBuf,
|
|
pub message: String,
|
|
}
|
|
|
|
#[derive(Debug, Clone, Default)]
|
|
pub struct SkillLoadOutcome {
|
|
pub skills: Vec<SkillMetadata>,
|
|
pub errors: Vec<SkillError>,
|
|
pub disabled_paths: HashSet<AbsolutePathBuf>,
|
|
pub(crate) skill_roots: Vec<AbsolutePathBuf>,
|
|
pub(crate) skill_root_by_path: Arc<HashMap<AbsolutePathBuf, AbsolutePathBuf>>,
|
|
pub(crate) file_systems_by_skill_path: SkillFileSystemsByPath,
|
|
pub(crate) implicit_skills_by_scripts_dir: Arc<HashMap<AbsolutePathBuf, SkillMetadata>>,
|
|
pub(crate) implicit_skills_by_doc_path: Arc<HashMap<AbsolutePathBuf, SkillMetadata>>,
|
|
}
|
|
|
|
impl SkillLoadOutcome {
|
|
pub fn is_skill_enabled(&self, skill: &SkillMetadata) -> bool {
|
|
!self.disabled_paths.contains(&skill.path_to_skills_md)
|
|
}
|
|
|
|
pub fn is_skill_allowed_for_implicit_invocation(&self, skill: &SkillMetadata) -> bool {
|
|
self.is_skill_enabled(skill) && skill.allows_implicit_invocation()
|
|
}
|
|
|
|
pub fn allowed_skills_for_implicit_invocation(&self) -> Vec<SkillMetadata> {
|
|
self.skills
|
|
.iter()
|
|
.filter(|skill| self.is_skill_allowed_for_implicit_invocation(skill))
|
|
.cloned()
|
|
.collect()
|
|
}
|
|
|
|
pub fn skills_with_enabled(&self) -> impl Iterator<Item = (&SkillMetadata, bool)> {
|
|
self.skills
|
|
.iter()
|
|
.map(|skill| (skill, self.is_skill_enabled(skill)))
|
|
}
|
|
|
|
pub(crate) fn file_system_for_skill(
|
|
&self,
|
|
skill: &SkillMetadata,
|
|
) -> Option<Arc<dyn ExecutorFileSystem>> {
|
|
self.file_systems_by_skill_path
|
|
.get(&skill.path_to_skills_md)
|
|
}
|
|
}
|
|
|
|
/// Immutable snapshot of host-owned skills and the filesystem mapping needed
|
|
/// to read each skill through the environment that discovered it.
|
|
#[derive(Debug, Clone)]
|
|
pub struct HostSkillsSnapshot {
|
|
outcome: Arc<SkillLoadOutcome>,
|
|
}
|
|
|
|
impl HostSkillsSnapshot {
|
|
pub fn new(outcome: Arc<SkillLoadOutcome>) -> Self {
|
|
Self { outcome }
|
|
}
|
|
|
|
pub fn outcome(&self) -> &SkillLoadOutcome {
|
|
self.outcome.as_ref()
|
|
}
|
|
|
|
pub async fn read_skill_text(&self, skill: &SkillMetadata) -> io::Result<String> {
|
|
let fs = self
|
|
.outcome
|
|
.file_system_for_skill(skill)
|
|
.unwrap_or_else(|| Arc::clone(&LOCAL_FS));
|
|
let path = PathUri::from_abs_path(&skill.path_to_skills_md);
|
|
fs.read_file_text(&path, /*sandbox*/ None).await
|
|
}
|
|
}
|
|
|
|
#[derive(Clone, Default)]
|
|
pub(crate) struct SkillFileSystemsByPath {
|
|
values: Arc<HashMap<AbsolutePathBuf, Arc<dyn ExecutorFileSystem>>>,
|
|
}
|
|
|
|
impl SkillFileSystemsByPath {
|
|
pub(crate) fn new(values: HashMap<AbsolutePathBuf, Arc<dyn ExecutorFileSystem>>) -> Self {
|
|
Self {
|
|
values: Arc::new(values),
|
|
}
|
|
}
|
|
|
|
fn get(&self, path: &AbsolutePathBuf) -> Option<Arc<dyn ExecutorFileSystem>> {
|
|
self.values.get(path).map(Arc::clone)
|
|
}
|
|
|
|
fn retain_paths(&mut self, paths: &HashSet<AbsolutePathBuf>) {
|
|
self.values = Arc::new(
|
|
self.values
|
|
.iter()
|
|
.filter(|(path, _)| paths.contains(*path))
|
|
.map(|(path, fs)| (path.clone(), Arc::clone(fs)))
|
|
.collect(),
|
|
);
|
|
}
|
|
}
|
|
|
|
impl fmt::Debug for SkillFileSystemsByPath {
|
|
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
|
f.debug_struct("SkillFileSystemsByPath")
|
|
.field("len", &self.values.len())
|
|
.finish()
|
|
}
|
|
}
|
|
|
|
pub fn filter_skill_load_outcome_for_product(
|
|
mut outcome: SkillLoadOutcome,
|
|
restriction_product: Option<Product>,
|
|
) -> SkillLoadOutcome {
|
|
outcome
|
|
.skills
|
|
.retain(|skill| skill.matches_product_restriction_for_product(restriction_product));
|
|
let retained_paths: HashSet<AbsolutePathBuf> = outcome
|
|
.skills
|
|
.iter()
|
|
.map(|skill| skill.path_to_skills_md.clone())
|
|
.collect();
|
|
outcome
|
|
.file_systems_by_skill_path
|
|
.retain_paths(&retained_paths);
|
|
outcome.skill_root_by_path = Arc::new(
|
|
outcome
|
|
.skill_root_by_path
|
|
.iter()
|
|
.filter(|(path, _)| retained_paths.contains(*path))
|
|
.map(|(path, root)| (path.clone(), root.clone()))
|
|
.collect(),
|
|
);
|
|
let retained_roots: HashSet<AbsolutePathBuf> =
|
|
outcome.skill_root_by_path.values().cloned().collect();
|
|
outcome
|
|
.skill_roots
|
|
.retain(|root| retained_roots.contains(root));
|
|
outcome.implicit_skills_by_scripts_dir = Arc::new(
|
|
outcome
|
|
.implicit_skills_by_scripts_dir
|
|
.iter()
|
|
.filter(|(_, skill)| skill.matches_product_restriction_for_product(restriction_product))
|
|
.map(|(path, skill)| (path.clone(), skill.clone()))
|
|
.collect(),
|
|
);
|
|
outcome.implicit_skills_by_doc_path = Arc::new(
|
|
outcome
|
|
.implicit_skills_by_doc_path
|
|
.iter()
|
|
.filter(|(_, skill)| skill.matches_product_restriction_for_product(restriction_product))
|
|
.map(|(path, skill)| (path.clone(), skill.clone()))
|
|
.collect(),
|
|
);
|
|
outcome
|
|
}
|