Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

Restore compatibility skill lookup fallback

Yeachan-Heo549ad7c3afc8
diff --git a/rust/crates/tools/src/lib.rs b/rust/crates/tools/src/lib.rs
index f3f80102..7de712f8 100644
--- a/rust/crates/tools/src/lib.rs
+++ b/rust/crates/tools/src/lib.rs
@@ -2974,7 +2974,263 @@ fn todo_store_path() -> Result<std::path::PathBuf, String> {
fn resolve_skill_path(skill: &str) -> Result<std::path::PathBuf, String> {
let cwd = std::env::current_dir().map_err(|error| error.to_string())?;
- commands::resolve_skill_path(&cwd, skill).map_err(|error| error.to_string())
+ match commands::resolve_skill_path(&cwd, skill) {
+ Ok(path) => Ok(path),
+ Err(_) => resolve_skill_path_from_compat_roots(skill),
+ }
+}
+
+fn resolve_skill_path_from_compat_roots(skill: &str) -> Result<std::path::PathBuf, String> {
+ let requested = skill.trim().trim_start_matches('/').trim_start_matches('$');
+ if requested.is_empty() {
+ return Err(String::from("skill must not be empty"));
+ }
+
+ for root in skill_lookup_roots() {
+ if let Some(path) = resolve_skill_path_in_root(&root, requested) {
+ return Ok(path);
+ }
+ }
+
+ Err(format!("unknown skill: {requested}"))
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum SkillLookupOrigin {
+ SkillsDir,
+ LegacyCommandsDir,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct SkillLookupRoot {
+ path: std::path::PathBuf,
+ origin: SkillLookupOrigin,
+}
+
+fn skill_lookup_roots() -> Vec<SkillLookupRoot> {
+ let mut roots = Vec::new();
+
+ if let Ok(cwd) = std::env::current_dir() {
+ push_project_skill_lookup_roots(&mut roots, &cwd);
+ }
+
+ if let Ok(claw_config_home) = std::env::var("CLAW_CONFIG_HOME") {
+ push_prefixed_skill_lookup_roots(&mut roots, std::path::Path::new(&claw_config_home));
+ }
+ if let Ok(codex_home) = std::env::var("CODEX_HOME") {
+ push_prefixed_skill_lookup_roots(&mut roots, std::path::Path::new(&codex_home));
+ }
+ if let Ok(home) = std::env::var("HOME") {
+ push_home_skill_lookup_roots(&mut roots, std::path::Path::new(&home));
+ }
+ if let Ok(claude_config_dir) = std::env::var("CLAUDE_CONFIG_DIR") {
+ let claude_config_dir = std::path::PathBuf::from(claude_config_dir);
+ push_skill_lookup_root(
+ &mut roots,
+ claude_config_dir.join("skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ &mut roots,
+ claude_config_dir.join("skills").join("omc-learned"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ &mut roots,
+ claude_config_dir.join("commands"),
+ SkillLookupOrigin::LegacyCommandsDir,
+ );
+ }
+ push_skill_lookup_root(
+ &mut roots,
+ std::path::PathBuf::from("/home/bellman/.claw/skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ &mut roots,
+ std::path::PathBuf::from("/home/bellman/.codex/skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+
+ roots
+}
+
+fn push_project_skill_lookup_roots(roots: &mut Vec<SkillLookupRoot>, cwd: &std::path::Path) {
+ for ancestor in cwd.ancestors() {
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".omc"));
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".agents"));
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".claw"));
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".codex"));
+ push_prefixed_skill_lookup_roots(roots, &ancestor.join(".claude"));
+ }
+}
+
+fn push_home_skill_lookup_roots(roots: &mut Vec<SkillLookupRoot>, home: &std::path::Path) {
+ push_prefixed_skill_lookup_roots(roots, &home.join(".omc"));
+ push_prefixed_skill_lookup_roots(roots, &home.join(".claw"));
+ push_prefixed_skill_lookup_roots(roots, &home.join(".codex"));
+ push_prefixed_skill_lookup_roots(roots, &home.join(".claude"));
+ push_skill_lookup_root(
+ roots,
+ home.join(".agents").join("skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ roots,
+ home.join(".config").join("opencode").join("skills"),
+ SkillLookupOrigin::SkillsDir,
+ );
+ push_skill_lookup_root(
+ roots,
+ home.join(".claude").join("skills").join("omc-learned"),
+ SkillLookupOrigin::SkillsDir,
+ );
+}
+
+fn push_prefixed_skill_lookup_roots(roots: &mut Vec<SkillLookupRoot>, prefix: &std::path::Path) {
+ push_skill_lookup_root(roots, prefix.join("skills"), SkillLookupOrigin::SkillsDir);
+ push_skill_lookup_root(
+ roots,
+ prefix.join("commands"),
+ SkillLookupOrigin::LegacyCommandsDir,
+ );
+}
+
+fn push_skill_lookup_root(
+ roots: &mut Vec<SkillLookupRoot>,
+ path: std::path::PathBuf,
+ origin: SkillLookupOrigin,
+) {
+ if path.is_dir() && !roots.iter().any(|existing| existing.path == path) {
+ roots.push(SkillLookupRoot { path, origin });
+ }
+}
+
+fn resolve_skill_path_in_root(
+ root: &SkillLookupRoot,
+ requested: &str,
+) -> Option<std::path::PathBuf> {
+ match root.origin {
+ SkillLookupOrigin::SkillsDir => resolve_skill_path_in_skills_dir(&root.path, requested),
+ SkillLookupOrigin::LegacyCommandsDir => {
+ resolve_skill_path_in_legacy_commands_dir(&root.path, requested)
+ }
+ }
+}
+
+fn resolve_skill_path_in_skills_dir(
+ root: &std::path::Path,
+ requested: &str,
+) -> Option<std::path::PathBuf> {
+ let direct = root.join(requested).join("SKILL.md");
+ if direct.is_file() {
+ return Some(direct);
+ }
+
+ let entries = std::fs::read_dir(root).ok()?;
+ for entry in entries.flatten() {
+ if !entry.path().is_dir() {
+ continue;
+ }
+ let skill_path = entry.path().join("SKILL.md");
+ if !skill_path.is_file() {
+ continue;
+ }
+ if entry
+ .file_name()
+ .to_string_lossy()
+ .eq_ignore_ascii_case(requested)
+ || skill_frontmatter_name_matches(&skill_path, requested)
+ {
+ return Some(skill_path);
+ }
+ }
+
+ None
+}
+
+fn resolve_skill_path_in_legacy_commands_dir(
+ root: &std::path::Path,
+ requested: &str,
+) -> Option<std::path::PathBuf> {
+ let direct_dir = root.join(requested).join("SKILL.md");
+ if direct_dir.is_file() {
+ return Some(direct_dir);
+ }
+
+ let direct_markdown = root.join(format!("{requested}.md"));
+ if direct_markdown.is_file() {
+ return Some(direct_markdown);
+ }
+
+ let entries = std::fs::read_dir(root).ok()?;
+ for entry in entries.flatten() {
+ let path = entry.path();
+ let candidate_path = if path.is_dir() {
+ let skill_path = path.join("SKILL.md");
+ if !skill_path.is_file() {
+ continue;
+ }
+ skill_path
+ } else if path
+ .extension()
+ .is_some_and(|ext| ext.to_string_lossy().eq_ignore_ascii_case("md"))
+ {
+ path
+ } else {
+ continue;
+ };
+
+ let matches_entry_name = candidate_path
+ .file_stem()
+ .is_some_and(|stem| stem.to_string_lossy().eq_ignore_ascii_case(requested))
+ || entry
+ .file_name()
+ .to_string_lossy()
+ .trim_end_matches(".md")
+ .eq_ignore_ascii_case(requested);
+ if matches_entry_name || skill_frontmatter_name_matches(&candidate_path, requested) {
+ return Some(candidate_path);
+ }
+ }
+
+ None
+}
+
+fn skill_frontmatter_name_matches(path: &std::path::Path, requested: &str) -> bool {
+ std::fs::read_to_string(path)
+ .ok()
+ .and_then(|contents| parse_skill_name(&contents))
+ .is_some_and(|name| name.eq_ignore_ascii_case(requested))
+}
+
+fn parse_skill_name(contents: &str) -> Option<String> {
+ parse_skill_frontmatter_value(contents, "name")
+}
+
+fn parse_skill_frontmatter_value(contents: &str, key: &str) -> Option<String> {
+ let mut lines = contents.lines();
+ if lines.next().map(str::trim) != Some("---") {
+ return None;
+ }
+
+ for line in lines {
+ let trimmed = line.trim();
+ if trimmed == "---" {
+ break;
+ }
+ if let Some(value) = trimmed.strip_prefix(&format!("{key}:")) {
+ let value = value
+ .trim()
+ .trim_matches(|ch| matches!(ch, '"' | '\''))
+ .trim();
+ if !value.is_empty() {
+ return Some(value.to_string());
+ }
+ }
+ }
+
+ None
}
const DEFAULT_AGENT_MODEL: &str = "claude-opus-4-6";