use std::path::{Path, PathBuf};
mod shell;
#[derive(Debug, Clone)]
pub struct Ranked<'a> {
pub node: &'a Proposed,
pub rows: usize,
pub tokens: u64,
}
#[must_use]
pub fn rank<'a>(proposed: &'a [Proposed], spec: &str) -> Vec<Ranked<'a>> {
let ranked = proposed
.iter()
.map(|node| {
let (rows, tokens) = row_weight(spec, &node.name);
Ranked { node, rows, tokens }
})
.collect();
heaviest_first(ranked)
}
#[must_use]
pub fn rank_in<'a>(
dir: &Path,
proposed: &'a [Proposed],
spec: &str,
) -> Vec<Ranked<'a>> {
let all = crate::fed::script_files(dir);
let modules: Vec<String> =
modules(dir).into_iter().map(|m| m.name).collect();
let ranked = proposed
.iter()
.map(|node| {
let owned = scripts_of(dir, node, &all);
let by_name = modules.contains(&node.name);
let (rows, tokens) = weight(spec, node, by_name, &owned, &all);
Ranked { node, rows, tokens }
})
.collect();
heaviest_first(ranked)
}
fn heaviest_first(mut out: Vec<Ranked<'_>>) -> Vec<Ranked<'_>> {
out.sort_by(|a, b| {
b.rows
.cmp(&a.rows)
.then_with(|| a.node.evidence.cmp(&b.node.evidence))
.then_with(|| a.node.name.cmp(&b.node.name))
});
out
}
#[must_use]
pub fn uniform_evidence(proposed: &[Proposed]) -> bool {
let mut grades = proposed.iter().map(|p| p.evidence);
let Some(first) = grades.next() else {
return false;
};
proposed.len() > 1 && grades.all(|g| g == first)
}
#[cfg(test)]
#[path = "tests/propose.rs"]
mod tests;
const VOCAB: [(&str, &[&str]); 9] = [
(
"fed",
&[
"§f",
"§n",
"edge",
"dag",
"cycle",
"chain",
"discover",
"graph",
"orphan",
"promotion",
],
),
("lens", &["lens", "pack", "budget", "depth", "why", "facet"]),
("tokens", &["token", "tier", "itok", "count", "ceiling"]),
("spec", &["microlith", "section", "record", "format", "fmt"]),
("ollama", &["ollama", "endpoint", "retry", "model"]),
("tdd", &["tdd", "judge", "red", "green", "repair"]),
("plan", &["plan", "apply", "horizon", "needs", "actionable"]),
("review", &["review", "unwired", "negative"]),
("state", &["state", "cache", "idempot"]),
];
#[derive(Debug, Clone, PartialEq, Eq)]
pub enum Proposal {
Move(&'static str),
Decompose(Vec<&'static str>),
Keep,
}
#[must_use]
pub fn propose(text: &str) -> Proposal {
let t = text.to_lowercase();
let hits: Vec<&'static str> = VOCAB
.iter()
.filter(|(_, ks)| ks.iter().any(|k| t.contains(k)))
.map(|(n, _)| *n)
.collect();
match hits.as_slice() {
[one] => Proposal::Move(one),
[] => Proposal::Keep,
_ => Proposal::Decompose(hits),
}
}
fn naming_rows(spec: &str, name: &str) -> Vec<String> {
law_lines(spec)
.filter(|line| names_word(line, name))
.map(str::to_string)
.collect()
}
fn law_lines(spec: &str) -> impl Iterator<Item = &str> {
let mut structural = false;
spec.lines().filter(move |line| {
if let Some(section) = line.strip_prefix("## \u{a7}") {
structural = section.starts_with('F') || section.starts_with('N');
return false;
}
!structural
})
}
fn names_word(line: &str, name: &str) -> bool {
line.split(|c: char| !c.is_alphanumeric() && c != '_')
.any(|w| w == name)
}
#[cfg(test)]
#[path = "tests/split.rs"]
mod split_tests;
#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
pub enum Evidence {
Declared,
Cohesion,
Published,
Drawn,
}
impl Evidence {
#[must_use]
pub fn label(self) -> &'static str {
match self {
Self::Drawn => "directory",
Self::Published => "pub mod",
Self::Cohesion => "family",
Self::Declared => "declared",
}
}
}
#[derive(Debug, Clone, PartialEq, Eq)]
pub struct Proposed {
pub name: String,
pub evidence: Evidence,
pub split_layout: bool,
pub members: Vec<String>,
pub shared: Vec<String>,
}
#[must_use]
pub fn structure(dir: &Path) -> Vec<Proposed> {
let mut out = modules(dir);
let flat = !dir.join("src").is_dir();
for c in shell::candidates(dir, &crate::fed::script_files(dir)) {
let same_dir = flat && c.evidence == Evidence::Drawn;
if !(same_dir && out.iter().any(|p| p.name == c.name)) {
out.push(c);
}
}
out
}
#[must_use]
pub fn modules(dir: &Path) -> Vec<Proposed> {
let src = if dir.join("src").is_dir() {
dir.join("src")
} else {
dir.to_path_buf()
};
let entry = ["lib.rs", "main.rs", "mod.rs"]
.iter()
.map(|f| src.join(f))
.find(|p| p.is_file());
let decls = entry
.and_then(|p| std::fs::read_to_string(p).ok())
.map(|t| crate::code::mod_decls(&t))
.unwrap_or_default();
let mut out: Vec<Proposed> = Vec::new();
for family in families(&decls) {
out.push(proposed_family(&src, family));
}
for d in &decls {
if out.iter().any(|p| p.members.contains(&d.name)) {
continue;
}
let evidence = if src.join(&d.name).is_dir() {
Evidence::Drawn
} else if d.is_pub {
Evidence::Published
} else {
Evidence::Declared
};
out.push(Proposed {
split_layout: src.join(&d.name).is_dir()
&& src.join(format!("{}.rs", d.name)).is_file(),
name: d.name.clone(),
evidence,
members: vec![d.name.clone()],
shared: Vec::new(),
});
}
out.sort_by(|a, b| b.evidence.cmp(&a.evidence).then(a.name.cmp(&b.name)));
out
}
fn families(decls: &[crate::code::ModDecl]) -> Vec<Vec<String>> {
let mut out = Vec::new();
for suffix in ["cmd", "fmt", "args"] {
let members: Vec<String> = decls
.iter()
.map(|d| d.name.clone())
.filter(|n| n.len() > suffix.len() && n.ends_with(suffix))
.collect();
if members.len() >= 3 {
out.push(members);
}
}
out
}
fn proposed_family(src: &Path, members: Vec<String>) -> Proposed {
let uses: Vec<Vec<String>> = members
.iter()
.filter_map(|m| {
std::fs::read_to_string(src.join(format!("{m}.rs"))).ok()
})
.map(|t| crate::code::crate_uses(&t))
.collect();
let shared = shared_across(&uses);
let name = members
.first()
.and_then(|m| m.get(m.len().saturating_sub(3)..))
.unwrap_or("group")
.to_string();
Proposed {
name,
evidence: Evidence::Cohesion,
members,
shared,
split_layout: false,
}
}
fn shared_across(lists: &[Vec<String>]) -> Vec<String> {
let Some(first) = lists.first() else {
return Vec::new();
};
first
.iter()
.filter(|n| lists.iter().all(|l| l.contains(n)))
.cloned()
.collect()
}
#[cfg(test)]
#[path = "tests/structure.rs"]
mod structure_tests;
#[must_use]
pub fn row_weight(spec: &str, name: &str) -> (usize, u64) {
let rows = naming_rows(spec, name);
let tokens = crate::tokens::count(&rows.join("\n")).tokens;
(rows.len(), tokens)
}
fn weight(
spec: &str,
p: &Proposed,
by_name: bool,
owned: &[PathBuf],
all: &[PathBuf],
) -> (usize, u64) {
let rows: Vec<&str> = law_lines(spec)
.filter(|line| {
(by_name && names_word(line, &p.name))
|| cited_scripts(line, all).iter().any(|s| owned.contains(s))
})
.collect();
let tokens = crate::tokens::count(&rows.join("\n")).tokens;
(rows.len(), tokens)
}
#[must_use]
pub fn scripts_of(dir: &Path, p: &Proposed, all: &[PathBuf]) -> Vec<PathBuf> {
let home = dir.join(&p.name);
if home.is_dir() {
return all
.iter()
.filter(|s| s.starts_with(&home))
.cloned()
.collect();
}
let files: Vec<PathBuf> = p
.members
.iter()
.map(|m| dir.join(format!("{m}.sh")))
.collect();
all.iter().filter(|s| files.contains(s)).cloned().collect()
}
#[must_use]
pub fn cited_scripts(text: &str, scripts: &[PathBuf]) -> Vec<PathBuf> {
let mut out: Vec<PathBuf> = shell::script_tokens(text)
.filter_map(|t| match shell::resolve(t, scripts).as_slice() {
[one] => Some((*one).clone()),
_ => None,
})
.collect();
out.sort();
out.dedup();
out
}
#[must_use]
pub fn ambiguous_scripts(spec: &str, scripts: &[PathBuf]) -> Vec<String> {
let mut out: Vec<String> = law_lines(spec)
.flat_map(shell::script_tokens)
.filter(|t| shell::resolve(t, scripts).len() > 1)
.map(str::to_string)
.collect();
out.sort();
out.dedup();
out
}
#[cfg(test)]
#[path = "tests/weight.rs"]
mod weight_tests;
#[cfg(test)]
#[path = "tests/shell.rs"]
mod shell_tests;