jettypod 4.4.120 → 4.4.121

package/crates/jettypod-core/src/config.rs

@@ -0,0 +1,397 @@
+//! Project configuration file I/O.
+//!
+//! Reads and writes `.jettypod/config.json` — project name, state,
+//! and runtime settings.
+//!
+//! Port of `lib/config.js`.
+
+use crate::error::{CoreError, Result};
+use serde::{Deserialize, Serialize};
+use std::path::Path;
+
+// ---------------------------------------------------------------------------
+// Types
+// ---------------------------------------------------------------------------
+
+/// Top-level project configuration stored in `.jettypod/config.json`.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProjectConfig {
+    #[serde(default = "default_name")]
+    pub name: String,
+
+    #[serde(default = "default_stage")]
+    pub stage: String,
+
+    #[serde(default = "default_bundles")]
+    pub bundles: Vec<String>,
+
+    #[serde(default = "default_project_state")]
+    pub project_state: String,
+
+    #[serde(default)]
+    pub project_discovery: ProjectDiscovery,
+
+    /// Optional override for the main branch name.
+    #[serde(rename = "mainBranch", skip_serializing_if = "Option::is_none")]
+    pub main_branch: Option<String>,
+
+    /// Preserve unknown fields for forward compatibility.
+    #[serde(flatten)]
+    pub extra: serde_json::Map<String, serde_json::Value>,
+}
+
+/// Project discovery state — tracks UX exploration workflow.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct ProjectDiscovery {
+    #[serde(default = "default_discovery_status")]
+    pub status: String,
+
+    #[serde(default)]
+    pub prototypes: Vec<serde_json::Value>,
+
+    #[serde(default)]
+    pub winner: Option<String>,
+
+    #[serde(default)]
+    pub rationale: Option<String>,
+
+    #[serde(default)]
+    pub started_date: Option<String>,
+
+    #[serde(default)]
+    pub completed_date: Option<String>,
+
+    #[serde(default)]
+    pub checkpoint: DiscoveryCheckpoint,
+}
+
+/// Checkpoint state within project discovery.
+#[derive(Debug, Clone, Serialize, Deserialize)]
+pub struct DiscoveryCheckpoint {
+    #[serde(default = "default_step")]
+    pub step: u32,
+
+    #[serde(default)]
+    pub user_journey: Option<String>,
+
+    #[serde(default)]
+    pub ux_approach: Option<String>,
+
+    #[serde(default)]
+    pub epics_created: bool,
+}
+
+// ---------------------------------------------------------------------------
+// Defaults
+// ---------------------------------------------------------------------------
+
+fn default_name() -> String {
+    "untitled".into()
+}
+fn default_stage() -> String {
+    "empty".into()
+}
+fn default_bundles() -> Vec<String> {
+    vec!["core".into()]
+}
+fn default_project_state() -> String {
+    "external".into()
+}
+fn default_discovery_status() -> String {
+    "not_started".into()
+}
+fn default_step() -> u32 {
+    1
+}
+
+impl Default for ProjectDiscovery {
+    fn default() -> Self {
+        Self {
+            status: default_discovery_status(),
+            prototypes: Vec::new(),
+            winner: None,
+            rationale: None,
+            started_date: None,
+            completed_date: None,
+            checkpoint: DiscoveryCheckpoint::default(),
+        }
+    }
+}
+
+impl Default for DiscoveryCheckpoint {
+    fn default() -> Self {
+        Self {
+            step: 1,
+            user_journey: None,
+            ux_approach: None,
+            epics_created: false,
+        }
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Valid values
+// ---------------------------------------------------------------------------
+
+const VALID_PROJECT_STATES: &[&str] = &["internal", "external"];
+
+/// Check whether a project state value is valid.
+pub fn is_valid_project_state(state: &str) -> bool {
+    VALID_PROJECT_STATES.contains(&state)
+}
+
+// ---------------------------------------------------------------------------
+// Operations
+// ---------------------------------------------------------------------------
+
+/// Read the project config from `.jettypod/config.json` under the given root.
+///
+/// Returns defaults if the file doesn't exist or is malformed.
+pub fn read(project_root: &Path) -> ProjectConfig {
+    let config_path = project_root.join(".jettypod").join("config.json");
+
+    if !config_path.exists() {
+        return default_config(project_root);
+    }
+
+    match std::fs::read_to_string(&config_path) {
+        Ok(contents) => match serde_json::from_str::<ProjectConfig>(&contents) {
+            Ok(mut cfg) => {
+                // Validate project_state — default to "external" if invalid
+                if !is_valid_project_state(&cfg.project_state) {
+                    cfg.project_state = "external".into();
+                }
+                cfg
+            }
+            Err(_) => default_config(project_root),
+        },
+        Err(_) => default_config(project_root),
+    }
+}
+
+/// Write the config to `.jettypod/config.json`.
+pub fn write(project_root: &Path, config: &ProjectConfig) -> Result<()> {
+    let dir = project_root.join(".jettypod");
+    std::fs::create_dir_all(&dir)?;
+
+    let json = serde_json::to_string_pretty(config)?;
+    std::fs::write(dir.join("config.json"), json)?;
+    Ok(())
+}
+
+/// Read, merge `updates` into the config, and write back.
+///
+/// The `updates` value is a partial JSON object whose keys overwrite
+/// matching keys in the current config.
+pub fn update(project_root: &Path, updates: serde_json::Value) -> Result<ProjectConfig> {
+    // Validate project_state if present in updates
+    if let Some(state) = updates.get("project_state").and_then(|v| v.as_str()) {
+        if !is_valid_project_state(state) {
+            return Err(CoreError::Config(format!(
+                "Invalid project_state: {}. Must be 'internal' or 'external'.",
+                state
+            )));
+        }
+    }
+
+    let current = read(project_root);
+    let mut current_val = serde_json::to_value(&current)?;
+
+    // Merge updates into current
+    if let (Some(base), Some(patch)) = (current_val.as_object_mut(), updates.as_object()) {
+        for (key, value) in patch {
+            base.insert(key.clone(), value.clone());
+        }
+    }
+
+    let updated: ProjectConfig = serde_json::from_value(current_val)?;
+    write(project_root, &updated)?;
+    Ok(updated)
+}
+
+/// Check whether `.jettypod/config.json` exists.
+pub fn exists(project_root: &Path) -> bool {
+    project_root.join(".jettypod").join("config.json").exists()
+}
+
+/// Resolve the default branch name.
+///
+/// Priority: config `mainBranch` → `git symbolic-ref` → `main` → `master`.
+pub fn resolve_default_branch(project_root: &Path) -> String {
+    let cfg = read(project_root);
+    if let Some(ref branch) = cfg.main_branch {
+        let trimmed = branch.trim();
+        if !trimmed.is_empty() {
+            return trimmed.to_string();
+        }
+    }
+
+    // Try git symbolic-ref
+    if let Ok(output) = std::process::Command::new("git")
+        .args(["symbolic-ref", "refs/remotes/origin/HEAD"])
+        .current_dir(project_root)
+        .output()
+    {
+        if output.status.success() {
+            let refname = String::from_utf8_lossy(&output.stdout).trim().to_string();
+            return refname.replace("refs/remotes/origin/", "");
+        }
+    }
+
+    // Try main, then master
+    for branch in &["main", "master"] {
+        if let Ok(output) = std::process::Command::new("git")
+            .args(["rev-parse", "--verify", branch])
+            .current_dir(project_root)
+            .output()
+        {
+            if output.status.success() {
+                return branch.to_string();
+            }
+        }
+    }
+
+    "main".into()
+}
+
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+
+fn default_config(project_root: &Path) -> ProjectConfig {
+    let name = project_root
+        .file_name()
+        .map(|n| n.to_string_lossy().to_string())
+        .unwrap_or_else(|| "untitled".into());
+
+    ProjectConfig {
+        name,
+        stage: "empty".into(),
+        bundles: vec!["core".into()],
+        project_state: "external".into(),
+        project_discovery: ProjectDiscovery::default(),
+        main_branch: None,
+        extra: serde_json::Map::new(),
+    }
+}
+
+// ---------------------------------------------------------------------------
+// Tests
+// ---------------------------------------------------------------------------
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn read_returns_defaults_when_missing() {
+        let dir = tempfile::tempdir().unwrap();
+        let cfg = read(dir.path());
+        assert_eq!(cfg.project_state, "external");
+        assert_eq!(cfg.project_discovery.status, "not_started");
+    }
+
+    #[test]
+    fn write_and_read_roundtrip() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(dir.path().join(".jettypod")).unwrap();
+
+        let mut cfg = default_config(dir.path());
+        cfg.project_state = "internal".into();
+        cfg.name = "test-project".into();
+
+        write(dir.path(), &cfg).unwrap();
+        let loaded = read(dir.path());
+
+        assert_eq!(loaded.name, "test-project");
+        assert_eq!(loaded.project_state, "internal");
+    }
+
+    #[test]
+    fn update_merges_fields() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(dir.path().join(".jettypod")).unwrap();
+
+        let cfg = default_config(dir.path());
+        write(dir.path(), &cfg).unwrap();
+
+        let updated = update(
+            dir.path(),
+            serde_json::json!({ "project_state": "internal" }),
+        )
+        .unwrap();
+
+        assert_eq!(updated.project_state, "internal");
+        // Name should be preserved
+        assert!(!updated.name.is_empty());
+    }
+
+    #[test]
+    fn update_rejects_invalid_state() {
+        let dir = tempfile::tempdir().unwrap();
+        std::fs::create_dir_all(dir.path().join(".jettypod")).unwrap();
+
+        let cfg = default_config(dir.path());
+        write(dir.path(), &cfg).unwrap();
+
+        let result = update(
+            dir.path(),
+            serde_json::json!({ "project_state": "invalid" }),
+        );
+        assert!(result.is_err());
+    }
+
+    #[test]
+    fn read_fixes_invalid_project_state() {
+        let dir = tempfile::tempdir().unwrap();
+        let jettypod_dir = dir.path().join(".jettypod");
+        std::fs::create_dir_all(&jettypod_dir).unwrap();
+        std::fs::write(
+            jettypod_dir.join("config.json"),
+            r#"{"project_state": "bogus", "name": "test"}"#,
+        )
+        .unwrap();
+
+        let cfg = read(dir.path());
+        assert_eq!(cfg.project_state, "external");
+        assert_eq!(cfg.name, "test");
+    }
+
+    #[test]
+    fn exists_works() {
+        let dir = tempfile::tempdir().unwrap();
+        assert!(!exists(dir.path()));
+
+        let jettypod_dir = dir.path().join(".jettypod");
+        std::fs::create_dir_all(&jettypod_dir).unwrap();
+        std::fs::write(jettypod_dir.join("config.json"), "{}").unwrap();
+
+        assert!(exists(dir.path()));
+    }
+
+    #[test]
+    fn preserves_extra_fields() {
+        let dir = tempfile::tempdir().unwrap();
+        let jettypod_dir = dir.path().join(".jettypod");
+        std::fs::create_dir_all(&jettypod_dir).unwrap();
+        std::fs::write(
+            jettypod_dir.join("config.json"),
+            r#"{"name":"test","custom_field":"preserved","project_state":"internal"}"#,
+        )
+        .unwrap();
+
+        let cfg = read(dir.path());
+        assert_eq!(
+            cfg.extra.get("custom_field").and_then(|v| v.as_str()),
+            Some("preserved")
+        );
+
+        // Write back and verify it's still there
+        write(dir.path(), &cfg).unwrap();
+        let reloaded = read(dir.path());
+        assert_eq!(
+            reloaded.extra.get("custom_field").and_then(|v| v.as_str()),
+            Some("preserved")
+        );
+    }
+}