@lamentis/naome 1.0.0

package/crates/naome-core/src/models.rs

@@ -0,0 +1,99 @@
+use std::error::Error;
+use std::fmt::{Display, Formatter};
+
+use serde::Serialize;
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct Decision {
+    pub schema: String,
+    pub state: String,
+    pub blocked: bool,
+    pub summary: String,
+    pub allowed_actions: Vec<String>,
+    pub next_action: String,
+    pub changed_paths: Vec<String>,
+    pub required_context: Vec<String>,
+    pub task: Option<TaskDecision>,
+    pub harness_health: Option<CheckDecision>,
+    pub task_admission: Option<CheckDecision>,
+}
+
+impl Decision {
+    pub fn new(
+        state: &str,
+        blocked: bool,
+        summary: &str,
+        allowed_actions: Vec<&str>,
+        next_action: &str,
+    ) -> Self {
+        Self {
+            schema: "naome.decision.v1".to_string(),
+            state: state.to_string(),
+            blocked,
+            summary: summary.to_string(),
+            allowed_actions: allowed_actions
+                .into_iter()
+                .map(ToString::to_string)
+                .collect(),
+            next_action: next_action.to_string(),
+            changed_paths: Vec::new(),
+            required_context: Vec::new(),
+            task: None,
+            harness_health: None,
+            task_admission: None,
+        }
+    }
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct TaskDecision {
+    pub id: Option<String>,
+    pub status: String,
+    pub request: Option<String>,
+    pub allowed_paths: Vec<String>,
+    pub required_check_ids: Vec<String>,
+}
+
+#[derive(Debug, Clone, Serialize, PartialEq, Eq)]
+#[serde(rename_all = "camelCase")]
+pub struct CheckDecision {
+    pub command: String,
+    pub exit_code: Option<i32>,
+    pub ok: bool,
+    pub output: String,
+}
+
+#[derive(Debug)]
+pub struct NaomeError {
+    message: String,
+}
+
+impl NaomeError {
+    pub fn new(message: impl Into<String>) -> Self {
+        Self {
+            message: message.into(),
+        }
+    }
+}
+
+impl Display for NaomeError {
+    fn fmt(&self, formatter: &mut Formatter<'_>) -> std::fmt::Result {
+        write!(formatter, "{}", self.message)
+    }
+}
+
+impl Error for NaomeError {}
+
+impl From<std::io::Error> for NaomeError {
+    fn from(error: std::io::Error) -> Self {
+        Self::new(error.to_string())
+    }
+}
+
+impl From<serde_json::Error> for NaomeError {
+    fn from(error: serde_json::Error) -> Self {
+        Self::new(error.to_string())
+    }
+}

package/crates/naome-core/src/paths.rs

@@ -0,0 +1,72 @@
+pub fn matches_any(path: &str, patterns: &[String]) -> bool {
+    patterns
+        .iter()
+        .any(|pattern| matches_pattern(path, pattern))
+}
+
+fn matches_pattern(path: &str, pattern: &str) -> bool {
+    let normalized_path = path.replace('\\', "/");
+    let normalized_pattern = pattern.replace('\\', "/");
+
+    if normalized_pattern == normalized_path {
+        return true;
+    }
+
+    if let Some(prefix) = normalized_pattern.strip_suffix("/**") {
+        return normalized_path == prefix || normalized_path.starts_with(&format!("{prefix}/"));
+    }
+
+    if !normalized_pattern.contains('*') {
+        return false;
+    }
+
+    wildcard_match(normalized_path.as_bytes(), normalized_pattern.as_bytes())
+}
+
+fn wildcard_match(value: &[u8], pattern: &[u8]) -> bool {
+    let (mut value_index, mut pattern_index) = (0, 0);
+    let mut star_index = None;
+    let mut match_index = 0;
+
+    while value_index < value.len() {
+        if pattern_index < pattern.len() && pattern[pattern_index] == value[value_index] {
+            value_index += 1;
+            pattern_index += 1;
+        } else if pattern_index < pattern.len() && pattern[pattern_index] == b'*' {
+            star_index = Some(pattern_index);
+            match_index = value_index;
+            pattern_index += 1;
+        } else if let Some(star) = star_index {
+            pattern_index = star + 1;
+            match_index += 1;
+            value_index = match_index;
+        } else {
+            return false;
+        }
+    }
+
+    while pattern_index < pattern.len() && pattern[pattern_index] == b'*' {
+        pattern_index += 1;
+    }
+
+    pattern_index == pattern.len()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::matches_any;
+
+    #[test]
+    fn supports_exact_prefix_and_wildcard_patterns() {
+        let patterns = vec![
+            "README.md".to_string(),
+            "docs/naome/**".to_string(),
+            "scripts/*.js".to_string(),
+        ];
+
+        assert!(matches_any("README.md", &patterns));
+        assert!(matches_any("docs/naome/testing.md", &patterns));
+        assert!(matches_any("scripts/check-task-state.js", &patterns));
+        assert!(!matches_any("src/main.rs", &patterns));
+    }
+}