chore: reorganize dev tools into dev/ directory and consolidate configsHEADmain

Move CI, dev tools, and configs from root-level scattered locations into
a
unified `dev/` directory structure. Update all references across build
scripts, documentation, and editor configurations.

Also consolidate editor config generation into build.rs for automated
synchronization of rust-analyzer settings across VS Code and Zed.

1 files changed, 103 insertions, 0 deletions

diff --git a/dev/ci/src/res/manifests.rs b/dev/ci/src/res/manifests.rs
new file mode 100644
index 0000000..7c72146
--- /dev/null
+++ b/dev/ci/src/res/manifests.rs
@@ -0,0 +1,103 @@
+use std::collections::HashMap;
+use std::path::{Path, PathBuf};
+
+use mingling::{Program, macros::program_setup};
+
+use crate::ThisProgram;
+
+/// Directories whose manifests are excluded from CI checks.
+///
+/// Path is relative to the crate source file (`dev/ci/src/res/`).
+const IGNORED_DIRS_FILE: &str = include_str!("../../../configs/ci-ignored-dirs.txt");
+
+/// All `Cargo.toml` manifests the CI will check.
+#[derive(Default, Clone)]
+pub struct Manifests {
+    pub path: Vec<PathBuf>,
+    /// Package name -> its manifest path.
+    pub package_dirs: HashMap<String, PathBuf>,
+}
+
+#[program_setup]
+pub fn manifests_setup(p: &mut Program<ThisProgram>) {
+    let path = cargo_tomls();
+    let package_dirs = path.iter().map(|p| (package_name(p), p.clone())).collect();
+    p.with_resource(Manifests { path, package_dirs });
+}
+
+/// Recursively collects every `Cargo.toml` under the current directory,
+/// skipping the legacy `.run` CI directory and any directory listed in
+/// `dev/configs/ci-ignored-dirs.txt`.
+#[must_use]
+fn cargo_tomls() -> Vec<PathBuf> {
+    let ignored = ignored_dirs();
+    let mut cargo_tomls = Vec::new();
+    let mut dirs = vec![PathBuf::from(".")];
+    while let Some(dir) = dirs.pop() {
+        if is_ignored(&dir.to_string_lossy(), &ignored) {
+            continue;
+        }
+        if let Ok(entries) = std::fs::read_dir(&dir) {
+            for entry in entries.flatten() {
+                let path = entry.path();
+                if path.is_dir() {
+                    // Skip the legacy `.run` CI directory
+                    if path.file_name().and_then(|n| n.to_str()) == Some(".run") {
+                        continue;
+                    }
+                    dirs.push(path);
+                } else if path.file_name().and_then(|n| n.to_str()) == Some("Cargo.toml") {
+                    cargo_tomls.push(path);
+                }
+            }
+        }
+    }
+    cargo_tomls
+}
+
+/// Parses `dev/configs/ci-ignored-dirs.txt` into directory prefixes:
+/// non-empty lines that do not start with `#`, with the trailing `/` stripped
+/// (e.g. `./.temp/` → `./.temp`).
+fn ignored_dirs() -> Vec<String> {
+    IGNORED_DIRS_FILE
+        .lines()
+        .map(str::trim)
+        .filter(|line| !line.is_empty() && !line.starts_with('#'))
+        .map(|line| line.trim_end_matches('/').to_string())
+        .collect()
+}
+
+/// Whether `path` (a walk directory, e.g. `./.temp` or `./examples`) is inside
+/// one of the ignored directories.
+fn is_ignored(path: &str, ignored: &[String]) -> bool {
+    ignored.iter().any(|dir| {
+        path.strip_prefix(dir.as_str())
+            .is_some_and(|rest| rest.is_empty() || rest.starts_with('/'))
+    })
+}
+
+/// Extracts the package name from a `Cargo.toml`.
+///
+/// Falls back to the parent directory name (e.g. `mingling_core/Cargo.toml` →
+/// `mingling_core`, workspace root → `(root)`), matching the legacy CI.
+fn package_name(path: &Path) -> String {
+    let fallback = || {
+        path.parent()
+            .and_then(|p| p.file_name())
+            .and_then(|n| n.to_str())
+            .unwrap_or("(root)")
+            .to_string()
+    };
+
+    let Ok(content) = std::fs::read_to_string(path) else {
+        return fallback();
+    };
+    let Ok(toml_value) = content.parse::<toml::Table>() else {
+        return fallback();
+    };
+    toml_value
+        .get("package")
+        .and_then(|p| p.get("name"))
+        .and_then(|n| n.as_str())
+        .map_or_else(fallback, str::to_string)
+}