post-merge

Author: orual

Cargo.lock

@@ -15,7 +15,7 @@ path = "src/main.rs"
 default = ["oauth", "discord"]
 oauth = ["pattern-core/oauth"]
 discord = ["pattern-discord"]
-legacy-convert = ["pattern-surreal-compat"]
+legacy-convert = ["dep:pattern-surreal-compat"]
 
 [dependencies]
 # Workspace dependencies

crates/pattern_cli/Cargo.toml

@@ -190,9 +190,9 @@ pub async fn add_rule(
     agent_name: &str,
     rule_type: &str,
     tool_name: &str,
-    _params: Option<&str>,
-    _conditions: Option<&str>,
-    _priority: u8,
+    params: Option<&str>,
+    conditions: Option<&str>,
+    priority: u8,
 ) -> Result<()> {
     let output = Output::new();
     let config = crate::helpers::load_config().await?;

crates/pattern_cli/src/commands/agent.rs

@@ -3,7 +3,7 @@
 //! These commands manage OAuth tokens for AI model providers. This is separate
 //! from ATProto authentication (see atproto.rs for Bluesky auth).
 
-use miette::Result;
+use miette::{IntoDiagnostic, Result};
 use owo_colors::OwoColorize;
 use pattern_auth::ProviderOAuthToken;
 use pattern_core::config::PatternConfig;
@@ -28,7 +28,7 @@ pub async fn login(provider: &str, config: &PatternConfig) -> Result<()> {
             output.info("Supported providers:", "anthropic");
             return Ok(());
         }
-    }
+    };
 
     output.section(&format!("OAuth Login: {}", provider.bright_cyan()));
 

crates/pattern_cli/src/commands/auth.rs

@@ -23,9 +23,9 @@ use crate::output::Output;
 pub async fn search_conversations(
     agent_name: &str,
     query: Option<&str>,
-    _role: Option<&str>,
-    _start_time: Option<&str>,
-    _end_time: Option<&str>,
+    role: Option<&str>,
+    start_time: Option<&str>,
+    end_time: Option<&str>,
     limit: usize,
 ) -> Result<()> {
     let output = Output::new();

crates/pattern_cli/src/commands/debug.rs

@@ -246,7 +246,7 @@ pub async fn import(
     file_path: PathBuf,
     rename_to: Option<String>,
     preserve_ids: bool,
-    _config: &PatternConfig,
+    config: &PatternConfig,
 ) -> Result<()> {
     let output = Output::new();
     let db = get_db(config).await?;

crates/pattern_cli/src/commands/export.rs

@@ -86,7 +86,7 @@ pub async fn add_member(
     group_name: &str,
     agent_name: &str,
     role: &str,
-    _capabilities: Option<&str>,
+    capabilities: Option<&str>,
     config: &PatternConfig,
 ) -> Result<()> {
     let output = Output::new();

crates/pattern_cli/src/commands/group.rs

@@ -123,15 +123,13 @@ proc-macro2-diagnostics = "0.10"
 miette = { workspace = true, features = ["fancy"] }
 
 [features]
-default = ["surreal-embedded", "embed-cloud", "file-watch"]
+default = [ "embed-cloud", "file-watch"]
 nd = []                                                                     # Enable neurodivergent features when pattern-nd is ready
 export = ["zstd"]                                                           # Agent export/import with compression
 oauth = ["reqwest-middleware", "http"]                                      # OAuth authentication support
 file-watch = []                                                             # File watching for data sources (notify always included)
 
 # Database backends
-surreal-embedded = []
-surreal-remote = []
 
 # Embedding backends
 embed-candle = [

crates/pattern_core/Cargo.toml

@@ -391,119 +391,3 @@ pub enum ActionPriority {
     /// Critical priority - requires immediate attention
     Critical,
 }
-
-use ferroid::{Base32SnowExt, SnowflakeGeneratorAsyncTokioExt, SnowflakeMastodonId};
-use std::fmt;
-use std::sync::OnceLock;
-
-/// Wrapper type for Snowflake IDs with proper serde support
-#[repr(transparent)]
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub struct SnowflakePosition(pub SnowflakeMastodonId);
-
-impl SnowflakePosition {
-    /// Create a new snowflake position
-    pub fn new(id: SnowflakeMastodonId) -> Self {
-        Self(id)
-    }
-}
-
-impl fmt::Display for SnowflakePosition {
-    fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
-        // Use the efficient base32 encoding via Display
-        write!(f, "{}", self.0)
-    }
-}
-
-impl FromStr for SnowflakePosition {
-    type Err = String;
-
-    fn from_str(s: &str) -> core::result::Result<Self, Self::Err> {
-        // Try parsing as base32 first
-        if let Ok(id) = SnowflakeMastodonId::decode(s) {
-            return Ok(Self(id));
-        }
-
-        // Fall back to parsing as raw u64
-        s.parse::<u64>()
-            .map(|raw| Self(SnowflakeMastodonId::from_raw(raw)))
-            .map_err(|e| format!("Failed to parse snowflake as base32 or u64: {}", e))
-    }
-}
-
-impl Serialize for SnowflakePosition {
-    fn serialize<S>(&self, serializer: S) -> core::result::Result<S::Ok, S::Error>
-    where
-        S: serde::Serializer,
-    {
-        // Serialize as string using Display
-        serializer.serialize_str(&self.to_string())
-    }
-}
-
-impl<'de> Deserialize<'de> for SnowflakePosition {
-    fn deserialize<D>(deserializer: D) -> core::result::Result<Self, D::Error>
-    where
-        D: serde::Deserializer<'de>,
-    {
-        // Deserialize from string and parse
-        let s = String::deserialize(deserializer)?;
-        s.parse::<Self>().map_err(serde::de::Error::custom)
-    }
-}
-
-/// Type alias for the Snowflake generator we're using
-type SnowflakeGen = ferroid::AtomicSnowflakeGenerator<SnowflakeMastodonId, ferroid::MonotonicClock>;
-
-/// Global ID generator for message positions using Snowflake IDs
-/// This provides distributed, monotonic IDs that work across processes
-static MESSAGE_POSITION_GENERATOR: OnceLock<SnowflakeGen> = OnceLock::new();
-
-pub fn get_position_generator() -> &'static SnowflakeGen {
-    MESSAGE_POSITION_GENERATOR.get_or_init(|| {
-        // Use machine ID 0 for now - in production this would be configurable
-        let clock = ferroid::MonotonicClock::with_epoch(ferroid::TWITTER_EPOCH);
-        ferroid::AtomicSnowflakeGenerator::new(0, clock)
-    })
-}
-
-/// Get the next message position synchronously
-///
-/// This is designed for use in synchronous contexts like Default impls.
-/// In practice, we don't generate messages fast enough to hit the sequence
-/// limit (65536/ms), so Pending should rarely happen in production.
-///
-/// When the sequence is exhausted (e.g., in parallel tests), this will block
-/// briefly until the next millisecond boundary to get a fresh sequence.
-pub fn get_next_message_position_sync() -> SnowflakePosition {
-    use ferroid::IdGenStatus;
-
-    let generator = get_position_generator();
-
-    loop {
-        match generator.next_id() {
-            IdGenStatus::Ready { id } => return SnowflakePosition::new(id),
-            IdGenStatus::Pending { yield_for } => {
-                // If yield_for is 0, we're at the sequence limit but still in the same millisecond.
-                // Wait at least 1ms to roll over to the next millisecond and reset the sequence.
-                let wait_ms = yield_for.max(1) as u64;
-                std::thread::sleep(std::time::Duration::from_millis(wait_ms));
-                // Loop will retry after the wait
-            }
-        }
-    }
-}
-
-/// Get the next message position as a Snowflake ID (async version)
-pub async fn get_next_message_position() -> SnowflakePosition {
-    let id = get_position_generator()
-        .try_next_id_async()
-        .await
-        .expect("for now we are assuming this succeeds");
-    SnowflakePosition::new(id)
-}
-
-/// Get the next message position as a String (for database storage)
-pub async fn get_next_message_position_string() -> String {
-    get_next_message_position().await.to_string()
-}

crates/pattern_core/src/agent/mod.rs

@@ -8,7 +8,7 @@ pub mod agent;
 pub mod config;
 pub mod context;
 pub mod coordination;
-//pub mod data_source;
+pub mod data_source;
 pub mod db;
 pub mod embeddings;
 pub mod error;