feat(config): allow other .json files when explicitly set

Closes #333

Author: JamieMason

src/cli.rs

@@ -713,10 +713,10 @@ fn additional_help() -> String {
 }
 
 fn validate_source(value: &str) -> Result<String, String> {
-  if value.ends_with("package.json") {
+  if value.ends_with(".json") {
     Ok(value.to_string())
   } else {
-    Err("must end with 'package.json'".to_string())
+    Err("must end with '.json'".to_string())
   }
 }
 

src/disk.rs

@@ -467,7 +467,7 @@ impl DiskIo for LiveDiskIo {
           None
         }
       })
-      .filter(|entry| entry.file_name() == "package.json")
+      .filter(|entry| entry.file_type().is_some_and(|t| t.is_file()) && entry.file_name().to_string_lossy().ends_with(".json"))
       .map(|entry| entry.into_path())
       .collect()
   }

src/source_patterns.rs

@@ -101,7 +101,7 @@ fn normalise_patterns(patterns: Vec<String>) -> Vec<String> {
 /// Normalize a source pattern by:
 /// 1. Preserving negation prefix (`!`) through normalization
 /// 2. Converting Windows backslashes to forward slashes for glob compatibility
-/// 3. Ensuring pattern ends with /package.json
+/// 3. Ensuring pattern ends with /package.json when no explicit `.json` filename was given
 /// 4. Anchoring slashless patterns to the workspace root with a leading `/` so gitignore basename rules don't make them match at any depth
 ///
 /// Examples:
@@ -110,17 +110,23 @@ fn normalise_patterns(patterns: Vec<String>) -> Vec<String> {
 /// - "package.json" -> "/package.json"
 /// - "apps\\*/package.json" -> "apps/*/package.json"
 /// - "!apps/test2" -> "!apps/test2/package.json"
+/// - "packages/*/package.public.json" -> "packages/*/package.public.json"
 pub fn normalise_pattern(mut pattern: String) -> String {
   let negated = pattern.starts_with('!');
   if negated {
     pattern.remove(0);
   }
   let mut normalized = pattern.replace('\\', "/");
-  if !normalized.contains("package.json") {
+  if !basename_ends_with_json(&normalized) {
     normalized = format!("{normalized}/package.json");
   }
   if !normalized.contains('/') {
     normalized = format!("/{normalized}");
   }
   if negated { format!("!{normalized}") } else { normalized }
 }
+
+fn basename_ends_with_json(pattern: &str) -> bool {
+  let basename = pattern.rsplit('/').next().unwrap_or(pattern);
+  basename.ends_with(".json")
+}

src/source_patterns_test.rs

@@ -34,6 +34,16 @@ fn normalizes_backslashes_to_forward_slashes() {
     ("!apps/test2/package.json", "!apps/test2/package.json"),
     ("!projects\\apps\\*", "!projects/apps/*/package.json"),
   ];
+  let non_standard_manifest_names = [
+    ("packages/*/package.public.json", "packages/*/package.public.json"),
+    ("packages/*/package.private.json", "packages/*/package.private.json"),
+    ("packages/foo/manifest.json", "packages/foo/manifest.json"),
+    ("package.public.json", "/package.public.json"),
+    ("packages\\*\\package.public.json", "packages/*/package.public.json"),
+    ("packages/*/*.json", "packages/*/*.json"),
+    ("!packages/foo/package.public.json", "!packages/foo/package.public.json"),
+    ("!packages/*/*.json", "!packages/*/*.json"),
+  ];
 
   let cases = windows_backslashes
     .iter()
@@ -43,7 +53,8 @@ fn normalizes_backslashes_to_forward_slashes() {
     .chain(forward_slashes_with_package_json.iter())
     .chain(bare_package_json.iter())
     .chain(glob_patterns.iter())
-    .chain(negated_globs.iter());
+    .chain(negated_globs.iter())
+    .chain(non_standard_manifest_names.iter());
 
   for (input, expected) in cases {
     let result = normalise_pattern(input.to_string());

src/test/builder.rs

@@ -46,6 +46,7 @@ pub struct TestBuilder {
   dependency_groups: Vec<Value>,
   package_manager: Option<PackageManager>,
   packages: Vec<Value>,
+  manifests_at: Vec<(String, Value)>,
   pnpm_yaml: Option<String>,
   bun_root: Option<Value>,
   registry_updates: Option<Value>,
@@ -67,6 +68,7 @@ impl TestBuilder {
       dependency_groups: vec![],
       package_manager: None,
       packages: vec![],
+      manifests_at: vec![],
       pnpm_yaml: None,
       bun_root: None,
       registry_updates: None,
@@ -163,6 +165,14 @@ impl TestBuilder {
     self
   }
 
+  /// Add a manifest file at an arbitrary path (e.g. `packages/foo/package.public.json`).
+  /// Goes through MockDisk like `with_package` but the caller controls the filename
+  /// so non-standard manifests (per issue #333) can be exercised.
+  pub fn with_manifest_at(mut self, path: &str, json: Value) -> Self {
+    self.manifests_at.push((path.to_string(), json));
+    self
+  }
+
   pub fn with_version_group(mut self, group: Value) -> Self {
     self.version_groups.push(group);
     self
@@ -275,6 +285,11 @@ impl TestBuilder {
       disk.add_json(&path, pkg);
     }
 
+    // Add manifests at caller-specified paths (e.g. package.public.json).
+    for (path, json) in &self.manifests_at {
+      disk.add_json(path, json);
+    }
+
     // Synthetic Bun root + bun.lock to trigger PM=Bun + catalog discovery.
     if let Some(ref root) = self.bun_root {
       disk.add_json("package.json", root);
@@ -425,6 +440,15 @@ impl TestBuilder {
         dirty: false,
       });
     }
+    for (path, json) in &self.manifests_at {
+      let raw = serde_json::to_string_pretty(json).unwrap_or_default();
+      package_json_files.push(File {
+        filepath: PathBuf::from(format!("/{path}")),
+        formatting: detect_formatting(&raw),
+        contents: json.clone(),
+        dirty: false,
+      });
+    }
     let pnpm_workspace = self
       .pnpm_yaml
       .as_ref()

src/test/builder_test.rs

@@ -108,3 +108,41 @@ async fn test_builder_with_update_target() {
   let foo_instance = ctx.instances.iter().find(|i| i.descriptor.internal_name == "foo").unwrap();
   assert_eq!(foo_instance.expected_specifier.borrow().as_ref().unwrap().get_raw(), "1.1.0");
 }
+
+// Issue #333: source patterns with non-standard filenames (e.g. package.public.json)
+// must be discovered when explicitly listed in `source`. The default rule of
+// appending `/package.json` still applies when no `.json` suffix is given.
+#[tokio::test]
+async fn test_builder_with_non_standard_manifest_filename() {
+  let ctx = TestBuilder::new()
+    .with_package(json!({
+      "name": "package-a",
+      "version": "1.0.0",
+      "dependencies": {"foo": "1.0.0"}
+    }))
+    .with_manifest_at(
+      "packages/package-a/package.public.json",
+      json!({
+        "name": "package-a-public",
+        "version": "2.0.0",
+        "dependencies": {"bar": "1.0.0"}
+      }),
+    )
+    .with_config(json!({
+      "source": ["packages/*/package.json", "packages/*/package.public.json"]
+    }))
+    .run()
+    .await;
+
+  let dep_names: Vec<&str> = ctx.instances.iter().map(|i| i.descriptor.internal_name.as_str()).collect();
+  assert!(
+    dep_names.contains(&"package-a"),
+    "package-a self-version missing; got {dep_names:?}"
+  );
+  assert!(dep_names.contains(&"foo"), "foo dependency missing; got {dep_names:?}");
+  assert!(
+    dep_names.contains(&"package-a-public"),
+    "package-a-public self-version missing; got {dep_names:?}"
+  );
+  assert!(dep_names.contains(&"bar"), "bar dependency missing; got {dep_names:?}");
+}

src/test/mock_disk.rs

@@ -178,7 +178,7 @@ impl DiskIo for MockDiskIo {
     self
       .files
       .keys()
-      .filter(|path| path.file_name().is_some_and(|n| n == "package.json"))
+      .filter(|path| path.file_name().and_then(|n| n.to_str()).is_some_and(|n| n.ends_with(".json")))
       .filter(|path| {
         let rel = path.strip_prefix(root).unwrap_or(path);
         overrides.matched(rel, false).is_whitelist()