feat(pathf): add build-time type path resolution system

Add `mingling_pathf` sub-crate and `pathf` feature for automatic
resolution of Mingling type module paths at build time. Scans source
files, identifies macro invocations via pattern matchers, and generates
mapping files consumed by `gen_program!()`.

1 files changed, 60 insertions, 0 deletions

diff --git a/mingling_pathf/src/patterns/dispatcher_clap.rs b/mingling_pathf/src/patterns/dispatcher_clap.rs
new file mode 100644
index 0000000..398b269
--- /dev/null
+++ b/mingling_pathf/src/patterns/dispatcher_clap.rs
@@ -0,0 +1,60 @@
+use syn::Item;
+
+use crate::pattern_analyzer::{AnalyzeItem, AnalyzePattern};
+
+/// Match structs annotated with `#[dispatcher_clap]`, extracting the entry type name (i.e., the struct name).
+///
+/// Covers the following forms:
+/// - `#[dispatcher_clap] struct EntryGreet { ... }`
+/// - `#[dispatcher_clap] #[command(...)] struct EntryGreet { ... }`
+pub struct DispatcherClapPattern;
+
+impl AnalyzePattern for DispatcherClapPattern {
+    fn contains(&self, content: &str) -> bool {
+        content.contains("dispatcher_clap(")
+    }
+
+    fn analyze(&self, content: &str) -> Vec<AnalyzeItem> {
+        let Ok(syntax) = syn::parse_file(content) else {
+            return Vec::new();
+        };
+
+        let mut items = Vec::new();
+
+        for item in &syntax.items {
+            match item {
+                Item::Struct(s) if has_attr(&s.attrs, "dispatcher_clap") => {
+                    items.push(AnalyzeItem {
+                        module: String::new(),
+                        item_name: s.ident.to_string(),
+                    });
+                }
+                Item::Mod(item_mod) => {
+                    if let Some((_, nested)) = &item_mod.content {
+                        for n in nested {
+                            if let Item::Struct(s) = n
+                                && has_attr(&s.attrs, "dispatcher_clap") {
+                                    items.push(AnalyzeItem {
+                                        module: item_mod.ident.to_string(),
+                                        item_name: s.ident.to_string(),
+                                    });
+                                }
+                        }
+                    }
+                }
+                _ => {}
+            }
+        }
+
+        items
+    }
+}
+
+fn has_attr(attrs: &[syn::Attribute], name: &str) -> bool {
+    attrs.iter().any(|a| {
+        a.path()
+            .segments
+            .last()
+            .is_some_and(|s| s.ident == name)
+    })
+}