chore: add skills system and ollama smoke test

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

Author: rexleimo

Cargo.lock

@@ -3,6 +3,7 @@ resolver = "2"
 members = [
     "crates/rexos",
     "crates/loopforge-cli",
+    "crates/rexos-skills",
     "crates/rexos-daemon",
     "crates/rexos-harness",
     "crates/rexos-kernel",
@@ -29,6 +30,7 @@ reqwest = { version = "0.12", default-features = false, features = ["json", "rus
 rusqlite = { version = "0.31", features = ["bundled"] }
 serde = { version = "1", features = ["derive"] }
 serde_json = "1"
+semver = { version = "1", features = ["serde"] }
 sha2 = "0.10"
 tempfile = "3"
 thiserror = "2"

Cargo.toml

@@ -23,6 +23,18 @@ impl RexosPaths {
         self.base_dir.join("rexos.db")
     }
 
+    pub fn workspace_skills_dir(workspace_root: &Path) -> PathBuf {
+        workspace_root.join(".loopforge/skills")
+    }
+
+    pub fn workspace_legacy_skills_dir(workspace_root: &Path) -> PathBuf {
+        workspace_root.join(".rexos/skills")
+    }
+
+    pub fn codex_home_skills_dir(home_dir: &Path) -> PathBuf {
+        home_dir.join(".codex/skills")
+    }
+
     pub fn ensure_dirs(&self) -> anyhow::Result<()> {
         std::fs::create_dir_all(&self.base_dir)
             .with_context(|| format!("create base dir: {}", self.base_dir.display()))?;
@@ -48,5 +60,23 @@ mod tests {
         assert!(paths.is_inside_base(&paths.base_dir.join("a/b/c")));
         assert!(!paths.is_inside_base(Path::new("/tmp/not-rexos")));
     }
-}
 
+    #[test]
+    fn skills_paths_follow_expected_layout() {
+        let workspace = Path::new("/tmp/workspace");
+        let home = Path::new("/tmp/home");
+
+        assert_eq!(
+            RexosPaths::workspace_skills_dir(workspace),
+            PathBuf::from("/tmp/workspace/.loopforge/skills")
+        );
+        assert_eq!(
+            RexosPaths::workspace_legacy_skills_dir(workspace),
+            PathBuf::from("/tmp/workspace/.rexos/skills")
+        );
+        assert_eq!(
+            RexosPaths::codex_home_skills_dir(home),
+            PathBuf::from("/tmp/home/.codex/skills")
+        );
+    }
+}

crates/rexos-kernel/src/paths.rs

@@ -0,0 +1,15 @@
+[package]
+name = "rexos-skills"
+version.workspace = true
+edition.workspace = true
+license.workspace = true
+rust-version.workspace = true
+
+[dependencies]
+anyhow.workspace = true
+serde.workspace = true
+toml.workspace = true
+semver.workspace = true
+
+[dev-dependencies]
+tempfile.workspace = true

crates/rexos-skills/Cargo.toml

@@ -0,0 +1,3 @@
+pub mod loader;
+pub mod manifest;
+pub mod resolver;

crates/rexos-skills/src/lib.rs

@@ -0,0 +1,91 @@
+use std::collections::BTreeMap;
+use std::path::{Path, PathBuf};
+
+use crate::manifest::{SkillManifest, parse_manifest};
+
+const SKILL_MANIFEST_FILE: &str = "skill.toml";
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum SkillSource {
+    Home,
+    WorkspaceLegacy,
+    Workspace,
+}
+
+#[derive(Debug, Clone)]
+pub struct DiscoveredSkill {
+    pub name: String,
+    pub root_dir: PathBuf,
+    pub manifest_path: PathBuf,
+    pub source: SkillSource,
+    pub manifest: SkillManifest,
+}
+
+pub fn discover_skills(
+    workspace_root: &Path,
+    home_skills_root: &Path,
+) -> anyhow::Result<BTreeMap<String, DiscoveredSkill>> {
+    let mut discovered = BTreeMap::new();
+
+    // Lower precedence first, later inserts override.
+    let roots = [
+        (SkillSource::Home, home_skills_root.to_path_buf()),
+        (
+            SkillSource::WorkspaceLegacy,
+            workspace_root.join(".rexos/skills"),
+        ),
+        (SkillSource::Workspace, workspace_root.join(".loopforge/skills")),
+    ];
+
+    for (source, root) in roots {
+        discover_under_root(&root, source, &mut discovered)?;
+    }
+
+    Ok(discovered)
+}
+
+fn discover_under_root(
+    root: &Path,
+    source: SkillSource,
+    out: &mut BTreeMap<String, DiscoveredSkill>,
+) -> anyhow::Result<()> {
+    if !root.is_dir() {
+        return Ok(());
+    }
+
+    for entry in std::fs::read_dir(root)? {
+        let entry = entry?;
+        if !entry.file_type()?.is_dir() {
+            continue;
+        }
+
+        let skill_root = entry.path();
+        let manifest_path = skill_root.join(SKILL_MANIFEST_FILE);
+        if !manifest_path.is_file() {
+            continue;
+        }
+
+        let raw = match std::fs::read_to_string(&manifest_path) {
+            Ok(raw) => raw,
+            Err(_) => continue,
+        };
+
+        let manifest = match parse_manifest(&raw) {
+            Ok(manifest) => manifest,
+            Err(_) => continue,
+        };
+        let name = manifest.name.clone();
+        out.insert(
+            name.clone(),
+            DiscoveredSkill {
+                name,
+                root_dir: skill_root,
+                manifest_path,
+                source,
+                manifest,
+            },
+        );
+    }
+
+    Ok(())
+}

crates/rexos-skills/src/loader.rs

@@ -0,0 +1,82 @@
+use anyhow::bail;
+use serde::Deserialize;
+
+pub fn parse_manifest(raw: &str) -> anyhow::Result<SkillManifest> {
+    let parsed: SkillManifestRaw = toml::from_str(raw)?;
+
+    let name = parsed.name.trim().to_string();
+    if name.is_empty() {
+        bail!("name cannot be empty");
+    }
+
+    let entry = parsed.entry.trim().to_string();
+    if entry.is_empty() {
+        bail!("entry cannot be empty");
+    }
+
+    let permissions = parsed
+        .permissions
+        .into_iter()
+        .map(|p| p.trim().to_string())
+        .filter(|p| !p.is_empty())
+        .collect::<Vec<_>>();
+
+    let mut dependencies = Vec::with_capacity(parsed.dependencies.len());
+    for dep in parsed.dependencies {
+        let dep_name = dep.name.trim().to_string();
+        if dep_name.is_empty() {
+            bail!("dependency.name cannot be empty");
+        }
+        let version_req = dep
+            .version_req
+            .or(dep.version)
+            .unwrap_or(semver::VersionReq::STAR);
+        dependencies.push(SkillDependency {
+            name: dep_name,
+            version_req,
+        });
+    }
+
+    Ok(SkillManifest {
+        name,
+        version: parsed.version,
+        entry,
+        permissions,
+        dependencies,
+    })
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SkillManifest {
+    pub name: String,
+    pub version: semver::Version,
+    pub entry: String,
+    pub permissions: Vec<String>,
+    pub dependencies: Vec<SkillDependency>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SkillDependency {
+    pub name: String,
+    pub version_req: semver::VersionReq,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct SkillManifestRaw {
+    name: String,
+    version: semver::Version,
+    entry: String,
+    #[serde(default)]
+    permissions: Vec<String>,
+    #[serde(default)]
+    dependencies: Vec<SkillDependencyRaw>,
+}
+
+#[derive(Debug, Clone, Deserialize)]
+struct SkillDependencyRaw {
+    name: String,
+    #[serde(default)]
+    version_req: Option<semver::VersionReq>,
+    #[serde(default)]
+    version: Option<semver::VersionReq>,
+}

crates/rexos-skills/src/manifest.rs

@@ -0,0 +1,94 @@
+use std::collections::{BTreeSet, HashMap};
+
+use anyhow::bail;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SkillNode {
+    pub name: String,
+    pub version: semver::Version,
+    pub dependencies: Vec<SkillDependencyConstraint>,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct SkillDependencyConstraint {
+    pub name: String,
+    pub version_req: semver::VersionReq,
+}
+
+pub fn resolve_load_order(nodes: Vec<SkillNode>) -> anyhow::Result<Vec<String>> {
+    if nodes.is_empty() {
+        return Ok(Vec::new());
+    }
+
+    let mut by_name: HashMap<String, SkillNode> = HashMap::new();
+    for node in nodes {
+        let name = node.name.trim().to_string();
+        if name.is_empty() {
+            bail!("skill name cannot be empty");
+        }
+        if by_name.insert(name.clone(), node).is_some() {
+            bail!("duplicate skill definition: {name}");
+        }
+    }
+
+    let mut indegree: HashMap<String, usize> = HashMap::new();
+    let mut outgoing: HashMap<String, Vec<String>> = HashMap::new();
+
+    for (name, node) in &by_name {
+        indegree.entry(name.clone()).or_insert(0);
+
+        for dep in &node.dependencies {
+            let dep_name = dep.name.trim();
+            if dep_name.is_empty() {
+                bail!("dependency name cannot be empty (skill={name})");
+            }
+
+            let Some(dep_node) = by_name.get(dep_name) else {
+                bail!("missing dependency: skill={name}, dependency={dep_name}");
+            };
+
+            if !dep.version_req.matches(&dep_node.version) {
+                bail!(
+                    "dependency version mismatch: skill={name}, dependency={dep_name}, requires={}, got={}",
+                    dep.version_req,
+                    dep_node.version
+                );
+            }
+
+            outgoing
+                .entry(dep_name.to_string())
+                .or_default()
+                .push(name.clone());
+            *indegree.entry(name.clone()).or_insert(0) += 1;
+        }
+    }
+
+    let mut ready = BTreeSet::new();
+    for (name, degree) in &indegree {
+        if *degree == 0 {
+            ready.insert(name.clone());
+        }
+    }
+
+    let mut order = Vec::with_capacity(by_name.len());
+    while let Some(name) = ready.pop_first() {
+        order.push(name.clone());
+
+        if let Some(next_skills) = outgoing.get(&name) {
+            for next in next_skills {
+                if let Some(entry) = indegree.get_mut(next) {
+                    *entry -= 1;
+                    if *entry == 0 {
+                        ready.insert(next.clone());
+                    }
+                }
+            }
+        }
+    }
+
+    if order.len() != by_name.len() {
+        bail!("dependency cycle detected in skills graph");
+    }
+
+    Ok(order)
+}