refactor: modularize cli and internalize competitor analysis

Author: rexleimo

CHANGELOG.md

@@ -18,6 +18,11 @@ All notable user-visible changes are documented in this file.
 
 - `loopforge onboard` no longer reports built-in starter success unless the expected artifact is actually created, and runtime JSON fallback now recognizes `function_name`-style tool calls emitted by real Ollama-compatible models.
 
+### Changed
+
+- Competitor-analysis posts were moved out of `docs-site/` into `docs/internal/competitive/`, and public blog/homepage references to OpenFang/OpenClaw were removed.
+- `loopforge release check` now fails when public docs contain competitor-analysis terms or when semver tags on HEAD do not match the requested release tag.
+
 ## [1.1.0] - 2026-03-06
 
 ### Added

crates/loopforge-cli/src/acp.rs

@@ -0,0 +1,88 @@
+use anyhow::Context;
+use rexos::memory::MemoryStore;
+
+pub(crate) fn load_acp_events(
+    memory: &MemoryStore,
+    session: Option<&str>,
+    limit: usize,
+) -> anyhow::Result<Vec<serde_json::Value>> {
+    let raw = memory
+        .kv_get("rexos.acp.events")
+        .context("kv_get rexos.acp.events")?
+        .unwrap_or_else(|| "[]".to_string());
+    let mut events: Vec<serde_json::Value> = serde_json::from_str(&raw).unwrap_or_default();
+
+    if let Some(session) = session {
+        let session = session.trim();
+        if !session.is_empty() {
+            events.retain(|ev| ev.get("session_id").and_then(|v| v.as_str()) == Some(session));
+        }
+    }
+
+    let wanted = limit.max(1);
+    if events.len() > wanted {
+        events = events.split_off(events.len() - wanted);
+    }
+    Ok(events)
+}
+
+pub(crate) fn load_acp_checkpoints(
+    memory: &MemoryStore,
+    session: &str,
+) -> anyhow::Result<Vec<serde_json::Value>> {
+    let session = session.trim();
+    if session.is_empty() {
+        anyhow::bail!("session is empty");
+    }
+    let key = format!("rexos.acp.checkpoints.{session}");
+    let raw = memory
+        .kv_get(&key)
+        .with_context(|| format!("kv_get {key}"))?
+        .unwrap_or_else(|| "[]".to_string());
+    let checkpoints: Vec<serde_json::Value> = serde_json::from_str(&raw).unwrap_or_default();
+    Ok(checkpoints)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use rexos::paths::RexosPaths;
+    use tempfile::tempdir;
+
+    #[test]
+    fn load_acp_events_filters_by_session_and_limit() {
+        let tmp = tempdir().unwrap();
+        let paths = RexosPaths {
+            base_dir: tmp.path().join(".loopforge"),
+        };
+        paths.ensure_dirs().unwrap();
+        let memory = MemoryStore::open_or_create(&paths).unwrap();
+        memory
+            .kv_set(
+                "rexos.acp.events",
+                r#"[
+  {"session_id":"s-1","step":1},
+  {"session_id":"s-2","step":2},
+  {"session_id":"s-1","step":3}
+]"#,
+            )
+            .unwrap();
+
+        let events = load_acp_events(&memory, Some("s-1"), 1).unwrap();
+        assert_eq!(events.len(), 1);
+        assert_eq!(events[0].get("step").and_then(|v| v.as_i64()), Some(3));
+    }
+
+    #[test]
+    fn load_acp_checkpoints_rejects_empty_session() {
+        let tmp = tempdir().unwrap();
+        let paths = RexosPaths {
+            base_dir: tmp.path().join(".loopforge"),
+        };
+        paths.ensure_dirs().unwrap();
+        let memory = MemoryStore::open_or_create(&paths).unwrap();
+
+        let err = load_acp_checkpoints(&memory, "  ").expect_err("empty session should fail");
+        assert!(err.to_string().contains("session is empty"));
+    }
+}

crates/loopforge-cli/src/config_validation.rs

@@ -0,0 +1,105 @@
+use rexos::{config::RexosConfig, paths::RexosPaths};
+
+#[derive(Debug, Clone, serde::Serialize)]
+pub(crate) struct ConfigValidationReport {
+    pub(crate) valid: bool,
+    pub(crate) config_path: String,
+    pub(crate) errors: Vec<String>,
+}
+
+pub(crate) fn validate_config(paths: &RexosPaths) -> ConfigValidationReport {
+    let config_path = paths.config_path();
+    let display_path = config_path.display().to_string();
+    let raw = match std::fs::read_to_string(&config_path) {
+        Ok(raw) => raw,
+        Err(e) => {
+            return ConfigValidationReport {
+                valid: false,
+                config_path: display_path,
+                errors: vec![format!("read config failed: {e}")],
+            };
+        }
+    };
+
+    let cfg: RexosConfig = match toml::from_str(&raw) {
+        Ok(cfg) => cfg,
+        Err(e) => {
+            return ConfigValidationReport {
+                valid: false,
+                config_path: display_path,
+                errors: vec![format!("parse config TOML failed: {e}")],
+            };
+        }
+    };
+
+    let mut errors = Vec::new();
+    for (route_name, provider_name) in [
+        ("planning", cfg.router.planning.provider.trim()),
+        ("coding", cfg.router.coding.provider.trim()),
+        ("summary", cfg.router.summary.provider.trim()),
+    ] {
+        if provider_name.is_empty() {
+            errors.push(format!("router.{route_name}.provider is empty"));
+            continue;
+        }
+        if !cfg.providers.contains_key(provider_name) {
+            errors.push(format!(
+                "router.{route_name}.provider references unknown provider '{provider_name}'"
+            ));
+        }
+    }
+
+    ConfigValidationReport {
+        valid: errors.is_empty(),
+        config_path: display_path,
+        errors,
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use tempfile::tempdir;
+
+    #[test]
+    fn validate_config_reports_success_for_default_config() {
+        let tmp = tempdir().unwrap();
+        let paths = RexosPaths {
+            base_dir: tmp.path().join(".loopforge"),
+        };
+        paths.ensure_dirs().unwrap();
+        RexosConfig::ensure_default(&paths).unwrap();
+
+        let report = validate_config(&paths);
+        assert!(report.valid, "expected config valid, got {report:?}");
+        assert!(
+            report.errors.is_empty(),
+            "expected no errors, got {report:?}"
+        );
+    }
+
+    #[test]
+    fn validate_config_reports_parse_error_for_invalid_toml() {
+        let tmp = tempdir().unwrap();
+        let paths = RexosPaths {
+            base_dir: tmp.path().join(".loopforge"),
+        };
+        paths.ensure_dirs().unwrap();
+        std::fs::write(
+            paths.config_path(),
+            "[providers
+broken = true",
+        )
+        .unwrap();
+
+        let report = validate_config(&paths);
+        assert!(!report.valid, "expected config invalid, got {report:?}");
+        assert!(
+            report
+                .errors
+                .iter()
+                .any(|e| e.contains("parse config TOML")),
+            "expected parse error, got {report:?}"
+        );
+    }
+}