Add lifecycle and integration actions

Author: TerminallyLazy

crates/tree-ring-memory-cli/src/actions/adapters.rs

@@ -0,0 +1,104 @@
+use std::path::PathBuf;
+
+use tree_ring_memory_core::{
+    collect_dox_memories, collect_revolve_memories, DoxSyncReport, DoxSyncRequest,
+    RevolveSyncReport, RevolveSyncRequest,
+};
+use tree_ring_memory_sqlite::SQLiteMemoryStore;
+
+use super::ActionResult;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct DoxSyncActionRequest {
+    pub source_root: PathBuf,
+    pub project: Option<String>,
+    pub dry_run: bool,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct DoxSyncActionReport {
+    pub report: DoxSyncReport,
+    pub dry_run: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct RevolveSyncActionRequest {
+    pub source_root: PathBuf,
+    pub project: Option<String>,
+    pub dry_run: bool,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct RevolveSyncActionReport {
+    pub report: RevolveSyncReport,
+    pub dry_run: bool,
+}
+
+pub fn sync_dox(
+    store: Option<&mut SQLiteMemoryStore>,
+    request: DoxSyncActionRequest,
+) -> ActionResult<DoxSyncActionReport> {
+    let mut dox_request = DoxSyncRequest::new(request.source_root);
+    dox_request.project = request.project;
+    let report = collect_dox_memories(&dox_request).map_err(|err| err.to_string())?;
+    if !request.dry_run {
+        let store = store.ok_or_else(|| {
+            "DOX sync action requires an open writable store when dry_run=false".to_string()
+        })?;
+        store
+            .put_many(&report.events)
+            .map_err(|err| err.to_string())?;
+    }
+    Ok(DoxSyncActionReport {
+        report,
+        dry_run: request.dry_run,
+    })
+}
+
+pub fn sync_revolve(
+    store: Option<&mut SQLiteMemoryStore>,
+    request: RevolveSyncActionRequest,
+) -> ActionResult<RevolveSyncActionReport> {
+    let mut revolve_request = RevolveSyncRequest::new(request.source_root);
+    revolve_request.project = request.project;
+    let report = collect_revolve_memories(&revolve_request).map_err(|err| err.to_string())?;
+    if !request.dry_run {
+        let store = store.ok_or_else(|| {
+            "Revolve sync action requires an open writable store when dry_run=false".to_string()
+        })?;
+        store
+            .put_many(&report.events)
+            .map_err(|err| err.to_string())?;
+    }
+    Ok(RevolveSyncActionReport {
+        report,
+        dry_run: request.dry_run,
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+    use tempfile::tempdir;
+
+    use super::*;
+
+    #[test]
+    fn dox_action_dry_run_does_not_write_events() {
+        let dir = tempdir().unwrap();
+        fs::write(dir.path().join("AGENTS.md"), "# Rules\n\nAlways run tests.").unwrap();
+
+        let report = sync_dox(
+            None,
+            DoxSyncActionRequest {
+                source_root: dir.path().to_path_buf(),
+                project: Some("tree-ring".to_string()),
+                dry_run: true,
+            },
+        )
+        .unwrap();
+
+        assert_eq!(report.report.memory_count, 1);
+        assert!(!dir.path().join("memory.sqlite").exists());
+    }
+}

crates/tree-ring-memory-cli/src/actions/integrations.rs

@@ -0,0 +1,39 @@
+use std::path::PathBuf;
+
+use crate::integrations::{scan_integrations, IntegrationScanReport};
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct IntegrationScanRequest {
+    pub source_root: PathBuf,
+}
+
+#[derive(Debug, Clone, PartialEq)]
+pub struct IntegrationScanActionReport {
+    pub report: IntegrationScanReport,
+}
+
+pub fn scan(request: IntegrationScanRequest) -> IntegrationScanActionReport {
+    IntegrationScanActionReport {
+        report: scan_integrations(&request.source_root),
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::fs;
+    use tempfile::tempdir;
+
+    use super::*;
+
+    #[test]
+    fn integration_action_scans_project_markers() {
+        let dir = tempdir().unwrap();
+        fs::write(dir.path().join("AGENTS.md"), "# Rules").unwrap();
+
+        let report = scan(IntegrationScanRequest {
+            source_root: dir.path().to_path_buf(),
+        });
+
+        assert!(report.report.detected_count > 0);
+    }
+}

crates/tree-ring-memory-cli/src/actions/lifecycle.rs

@@ -0,0 +1,118 @@
+use std::path::Path;
+
+use tree_ring_memory_core::{
+    consolidate_memories, plan_maintenance, ConsolidationPeriod, ConsolidationReport,
+    ConsolidationRequest, MaintenanceReport, MaintenanceRequest,
+};
+use tree_ring_memory_sqlite::SQLiteMemoryStore;
+
+use super::ActionResult;
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ConsolidateActionRequest {
+    pub period_type: String,
+    pub period_key: Option<String>,
+    pub project: Option<String>,
+    pub dry_run: bool,
+    pub force: bool,
+}
+
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct MaintainActionRequest {
+    pub project: Option<String>,
+    pub include_superseded: bool,
+    pub apply_expired: bool,
+    pub apply_secret_redactions: bool,
+    pub repair_fts: bool,
+}
+
+pub fn consolidation_request(
+    request: ConsolidateActionRequest,
+) -> ActionResult<ConsolidationRequest> {
+    Ok(ConsolidationRequest {
+        period_type: ConsolidationPeriod::parse(&request.period_type)
+            .map_err(|err| err.to_string())?,
+        period_key: request.period_key,
+        project: request.project,
+        dry_run: request.dry_run,
+        force: request.force,
+    })
+}
+
+pub fn consolidate(
+    store: &mut SQLiteMemoryStore,
+    request: ConsolidateActionRequest,
+) -> ActionResult<ConsolidationReport> {
+    let request = consolidation_request(request)?;
+    store.consolidate(&request).map_err(|err| err.to_string())
+}
+
+pub fn consolidate_dry_run_from_path(
+    db_path: &Path,
+    request: ConsolidateActionRequest,
+) -> ActionResult<ConsolidationReport> {
+    let request = consolidation_request(request)?;
+    if db_path.exists() {
+        let store = SQLiteMemoryStore::open_read_only(db_path).map_err(|err| err.to_string())?;
+        let events = store.list_all(false).map_err(|err| err.to_string())?;
+        consolidate_memories(&events, &request).map_err(|err| err.to_string())
+    } else {
+        consolidate_memories(&[], &request).map_err(|err| err.to_string())
+    }
+}
+
+pub fn maintenance_request(request: MaintainActionRequest) -> MaintenanceRequest {
+    MaintenanceRequest {
+        dry_run: !(request.apply_expired || request.apply_secret_redactions || request.repair_fts),
+        apply_expired: request.apply_expired,
+        apply_secret_redactions: request.apply_secret_redactions,
+        repair_fts: request.repair_fts,
+        include_superseded: request.include_superseded,
+        project: request.project,
+    }
+}
+
+pub fn maintain(
+    db_path: &Path,
+    store: Option<&mut SQLiteMemoryStore>,
+    request: MaintainActionRequest,
+) -> ActionResult<MaintenanceReport> {
+    let request = maintenance_request(request);
+    if request.dry_run && !db_path.exists() {
+        return Ok(plan_maintenance(&[], &request));
+    }
+    if let Some(store) = store {
+        return store.maintain(&request).map_err(|err| err.to_string());
+    }
+    let mut store = SQLiteMemoryStore::open_read_only(db_path).map_err(|err| err.to_string())?;
+    store.maintain(&request).map_err(|err| err.to_string())
+}
+
+#[cfg(test)]
+mod tests {
+    use tempfile::tempdir;
+
+    use super::*;
+
+    #[test]
+    fn maintenance_action_missing_store_is_non_mutating_dry_run() {
+        let dir = tempdir().unwrap();
+        let db_path = dir.path().join(".tree-ring/memory.sqlite");
+
+        let report = maintain(
+            &db_path,
+            None,
+            MaintainActionRequest {
+                project: None,
+                include_superseded: false,
+                apply_expired: false,
+                apply_secret_redactions: false,
+                repair_fts: false,
+            },
+        )
+        .unwrap();
+
+        assert_eq!(report.memory_count, 0);
+        assert!(!db_path.exists());
+    }
+}

crates/tree-ring-memory-cli/src/actions/mod.rs

@@ -1,5 +1,8 @@
+pub mod adapters;
 pub mod audit;
 pub mod export_import;
+pub mod integrations;
+pub mod lifecycle;
 pub mod recall;
 pub mod remember;