feat: packages shorthand, approval job handling, cigen_shallow_checkout, per-workflow outputs; migrate DocSpring jobs; split setup/main outputs

Author: ndbroadbent

schemas/v1/job-schema.json

@@ -178,10 +178,26 @@
           "type": "array",
           "description": "Package managers to use for dependency installation",
           "items": {
-            "type": "string",
-            "enum": ["node", "ruby", "python", "go"]
+            "oneOf": [
+              {
+                "type": "string",
+                "enum": ["node", "ruby", "python", "go"]
+              },
+              {
+                "type": "object",
+                "properties": {
+                  "name": {
+                    "type": "string",
+                    "enum": ["node", "ruby", "python", "go"]
+                  },
+                  "path": { "type": "string" }
+                },
+                "required": ["name", "path"],
+                "additionalProperties": false
+              }
+            ]
           },
-          "uniqueItems": true
+          "uniqueItems": false
         }
       ]
     },

src/commands/generate.rs

@@ -210,20 +210,101 @@ fn generate_from_jobs(
             }
         }
 
-        provider
-            .generate_all(
-                &loaded_config.config,
-                &workflows,
-                &loaded_config.commands,
-                &output_path,
-            )
-            .map_err(|e| anyhow::anyhow!("Failed to generate all workflows: {}", e))?;
+        // If any workflow has a specific output filename, generate each workflow separately
+        let mut any_per_workflow = false;
+        for (workflow_name, workflow_jobs) in workflows.iter() {
+            let workflow_config_path =
+                PathBuf::from(format!("workflows/{workflow_name}/config.yml"));
+            if workflow_config_path.exists() {
+                let workflow_config_str = std::fs::read_to_string(&workflow_config_path)?;
+                let workflow_overrides: serde_yaml::Value =
+                    serde_yaml::from_str(&workflow_config_str)?;
+                let merged_config = loaded_config.config.clone();
+                let workflow_config: cigen::models::Config =
+                    if let Some(obj) = workflow_overrides.as_mapping() {
+                        let mut base_value = serde_json::to_value(&merged_config)?;
+                        let override_value = serde_json::to_value(obj)?;
+                        if let (Some(base_obj), Some(override_obj)) =
+                            (base_value.as_object_mut(), override_value.as_object())
+                        {
+                            for (key, value) in override_obj {
+                                if !value.is_null() {
+                                    base_obj.insert(key.clone(), value.clone());
+                                }
+                            }
+                        }
+                        serde_json::from_value(base_value)?
+                    } else {
+                        merged_config
+                    };
+
+                if workflow_config.output_filename.is_some() {
+                    any_per_workflow = true;
+                    // Determine workflow-specific output path
+                    let workflow_output_path =
+                        if let Some(workflow_output) = &workflow_config.output_path {
+                            original_dir_path(Path::new(workflow_output))
+                        } else {
+                            output_path.clone()
+                        };
+
+                    // Apply package deduplication for this workflow
+                    let mut jobs_copy = workflow_jobs.clone();
+                    if jobs_copy.values().any(|job| job.packages.is_some()) {
+                        let project_root = if current_dir.ends_with(".cigen") {
+                            current_dir.parent().and_then(|p| p.to_str()).unwrap_or(".")
+                        } else {
+                            current_dir.to_str().unwrap_or(".")
+                        };
+                        let deduplicator =
+                            cigen::packages::deduplicator::PackageDeduplicator::new(project_root);
+                        deduplicator.process_jobs(&mut jobs_copy).map_err(|e| {
+                            anyhow::anyhow!("Failed to process package deduplication: {}", e)
+                        })?;
+                    }
 
-        println!(
-            "✅ Generated {} configuration for all workflows to {}",
-            provider.name(),
-            output_path.display()
-        );
+                    provider
+                        .generate_workflow(
+                            &workflow_config,
+                            workflow_name,
+                            &jobs_copy,
+                            &loaded_config.commands,
+                            &workflow_output_path,
+                        )
+                        .map_err(|e| {
+                            anyhow::anyhow!(
+                                "Failed to generate workflow '{}': {}",
+                                workflow_name,
+                                e
+                            )
+                        })?;
+
+                    println!(
+                        "✅ Generated {} workflow '{}' to {}",
+                        provider.name(),
+                        workflow_name,
+                        workflow_output_path.display()
+                    );
+                }
+            }
+        }
+
+        if !any_per_workflow {
+            provider
+                .generate_all(
+                    &loaded_config.config,
+                    &workflows,
+                    &loaded_config.commands,
+                    &output_path,
+                )
+                .map_err(|e| anyhow::anyhow!("Failed to generate all workflows: {}", e))?;
+
+            println!(
+                "✅ Generated {} configuration for all workflows to {}",
+                provider.name(),
+                output_path.display()
+            );
+        }
     }
 
     Ok(())

src/graph/dependency_graph.rs

@@ -198,6 +198,7 @@ mod tests {
             packages: None,
             steps: None,
             checkout: None,
+            job_type: None,
         }
     }
 

src/loader/config_loader.rs

@@ -44,8 +44,13 @@ impl<'a> ConfigLoader<'a> {
         let main_config: JsonValue = serde_yaml::from_str(&content)
             .with_context(|| format!("Failed to parse {}", config_path.display()))?;
 
-        // Load split configs from .cigen/config/
-        let config_dir = Path::new(".cigen/config");
+        // Load split configs; support running from project root or inside .cigen
+        let cwd = std::env::current_dir().unwrap();
+        let config_dir = if cwd.file_name() == Some(std::ffi::OsStr::new(".cigen")) {
+            Path::new("config")
+        } else {
+            Path::new(".cigen/config")
+        };
         let mut split_configs = Vec::new();
 
         if config_dir.exists() {
@@ -93,8 +98,13 @@ impl<'a> ConfigLoader<'a> {
         let processed = self.process_file_content(&config_path, &content)?;
         let main_config: JsonValue = serde_yaml::from_str(&processed)?;
 
-        // Load split configs with templating from .cigen/config/
-        let config_dir = Path::new(".cigen/config");
+        // Load split configs with templating; support running from project root or inside .cigen
+        let cwd = std::env::current_dir().unwrap();
+        let config_dir = if cwd.file_name() == Some(std::ffi::OsStr::new(".cigen")) {
+            Path::new("config")
+        } else {
+            Path::new(".cigen/config")
+        };
         let mut split_configs = Vec::new();
 
         if config_dir.exists() {

src/models/job.rs

@@ -52,15 +52,23 @@ pub struct Job {
     #[serde(skip_serializing_if = "Option::is_none")]
     pub services: Option<Vec<String>>,
 
-    #[serde(skip_serializing_if = "Option::is_none")]
-    #[serde(default, deserialize_with = "deserialize_string_or_vec")]
-    pub packages: Option<Vec<String>>,
+    #[serde(
+        skip_serializing_if = "Option::is_none",
+        default,
+        deserialize_with = "deserialize_packages"
+    )]
+    pub packages: Option<Vec<PackageSpec>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub steps: Option<Vec<Step>>,
 
     #[serde(skip_serializing_if = "Option::is_none")]
     pub checkout: Option<super::config::CheckoutSetting>,
+
+    /// CircleCI job type (e.g., approval)
+    #[serde(skip_serializing_if = "Option::is_none")]
+    #[serde(rename = "type")]
+    pub job_type: Option<String>,
 }
 
 /// Intermediate parsing structure for cache definitions that handles multiple YAML formats
@@ -205,6 +213,69 @@ impl Job {
     }
 }
 
+#[derive(Debug, Clone, Serialize, Deserialize, PartialEq, Eq, Hash)]
+#[serde(untagged)]
+pub enum PackageSpec {
+    /// Simple shorthand: "node", "ruby", etc.
+    Simple(String),
+    /// Extended form with path scoping (e.g., install under a subdirectory)
+    WithPath { name: String, path: String },
+}
+
+impl PackageSpec {
+    pub fn name(&self) -> &str {
+        match self {
+            PackageSpec::Simple(s) => s.as_str(),
+            PackageSpec::WithPath { name, .. } => name.as_str(),
+        }
+    }
+
+    pub fn path(&self) -> Option<&str> {
+        match self {
+            PackageSpec::Simple(_) => None,
+            PackageSpec::WithPath { path, .. } => Some(path.as_str()),
+        }
+    }
+}
+
+fn deserialize_packages<'de, D>(deserializer: D) -> Result<Option<Vec<PackageSpec>>, D::Error>
+where
+    D: Deserializer<'de>,
+{
+    use serde::de::Error;
+
+    let value: Option<serde_yaml::Value> = Option::deserialize(deserializer)?;
+
+    match value {
+        None => Ok(None),
+        Some(serde_yaml::Value::String(s)) => Ok(Some(vec![PackageSpec::Simple(s)])),
+        Some(serde_yaml::Value::Sequence(seq)) => {
+            let mut out: Vec<PackageSpec> = Vec::new();
+            for item in seq {
+                match item {
+                    serde_yaml::Value::String(s) => out.push(PackageSpec::Simple(s)),
+                    serde_yaml::Value::Mapping(_) => {
+                        let spec: PackageSpec =
+                            serde_yaml::from_value(item).map_err(D::Error::custom)?;
+                        out.push(spec);
+                    }
+                    _ => return Err(D::Error::custom("Invalid packages entry")),
+                }
+            }
+            Ok(Some(out))
+        }
+        Some(serde_yaml::Value::Mapping(map)) => {
+            // Support single object form: packages: { name: node, path: docs }
+            let spec: PackageSpec = serde_yaml::from_value(serde_yaml::Value::Mapping(map))
+                .map_err(D::Error::custom)?;
+            Ok(Some(vec![spec]))
+        }
+        Some(_) => Err(D::Error::custom(
+            "packages must be a string, array, or object",
+        )),
+    }
+}
+
 /// Custom deserializer for cache definitions that handles multiple YAML formats
 fn deserialize_cache_definitions<'de, D>(
     deserializer: D,

src/models/tests_packages.rs

@@ -0,0 +1,37 @@
+use crate::models::Job;
+
+#[test]
+fn parse_packages_shorthand_string() {
+    let yaml = r#"
+image: cimg/node:18
+packages: node
+"#;
+    let job: Job = serde_yaml::from_str(yaml).unwrap();
+    let pkgs = job.packages.unwrap();
+    assert_eq!(pkgs.len(), 1);
+    match &pkgs[0] {
+        crate::models::job::PackageSpec::Simple(s) => assert_eq!(s, "node"),
+        _ => panic!("expected simple package spec"),
+    }
+}
+
+#[test]
+fn parse_packages_object_with_path() {
+    let yaml = r#"
+image: cimg/node:18
+packages:
+  name: node
+  path: docs
+"#;
+    let job: Job = serde_yaml::from_str(yaml).unwrap();
+    let pkgs = job.packages.unwrap();
+    assert_eq!(pkgs.len(), 1);
+    match &pkgs[0] {
+        crate::models::job::PackageSpec::WithPath { name, path } => {
+            assert_eq!(name, "node");
+            assert_eq!(path, "docs");
+        }
+        _ => panic!("expected with-path package spec"),
+    }
+}
+