The design language that makes your AI harness better at design.
JavaScript
//! JS: live/source-search.mjs, lib/template-extensions.mjs (the live
//! subset), lib/is-generated.mjs. The project-source walk wrap and accept
//! share, the template-extension list it matches, and the generated-file
//! guard (git check-ignore + header markers).
use crate::util::{exists, is_dir, jsp, read_json, safe_read};
use once_cell::sync::Lazy;
use regex::Regex;
use serde_json::Value;
/// JS: SOURCE_SEARCH_DIRS
pub const SOURCE_SEARCH_DIRS: [&str; 9] = [
"src",
"app",
"pages",
"components",
"public",
"views",
"templates",
"lib",
".",
];
/// JS: NEVER_SOURCE_DIRS
pub const NEVER_SOURCE_DIRS: [&str; 3] = ["node_modules", ".git", ".impeccable"];
const MAX_DEPTH: usize = 5;
/// JS: LIVE_TEMPLATE_EXTENSIONS
pub const LIVE_TEMPLATE_EXTENSIONS: [&str; 9] = [
".html", ".jsx", ".tsx", ".vue", ".svelte", ".astro", ".ex", ".heex", ".eex",
];
/// `fs.readdirSync(dir, { withFileTypes: true })` as libuv returns it: sorted
/// by `strcmp` on the name (uv_fs_scandir sorts). A symlink is neither a file
/// nor a directory.
pub struct DirEnt {
pub name: String,
pub is_file: bool,
pub is_dir: bool,
}
pub fn read_dir_sorted(dir: &str) -> Option<Vec<DirEnt>> {
let rd = std::fs::read_dir(dir).ok()?;
let mut out: Vec<DirEnt> = Vec::new();
for e in rd.flatten() {
let name = e.file_name().to_string_lossy().into_owned();
let (is_file, is_dir) = match e.file_type() {
Ok(t) if t.is_symlink() => (false, false),
Ok(t) => (t.is_file(), t.is_dir()),
Err(_) => (false, false),
};
out.push(DirEnt {
name,
is_file,
is_dir,
});
}
out.sort_by(|a, b| a.name.as_bytes().cmp(b.name.as_bytes()));
Some(out)
}
/// JS: normalizeExtensionEntries(entries) → the `.ext` strings only.
fn normalize_extension_entries(entries: Option<&Value>) -> Vec<String> {
let mut out = Vec::new();
let Some(Value::Array(list)) = entries else {
return out;
};
for entry in list {
let raw = match entry {
Value::String(s) => Some(s.as_str()),
Value::Object(o) => o.get("ext").and_then(|v| v.as_str()),
_ => None,
};
let Some(raw) = raw else { continue };
let mut ext = impeccable_core::js::trim(raw).to_lowercase();
if ext.is_empty() {
continue;
}
if !ext.starts_with('.') {
ext = format!(".{}", ext);
}
out.push(ext);
}
out
}
/// JS: resolveLiveTemplateExtensions(cwd)
pub fn resolve_live_template_extensions(cwd: &str) -> Vec<String> {
let mut configured: Vec<String> = Vec::new();
for name in ["config.json", "config.local.json"] {
let raw = read_json(&jsp::join(&[cwd, ".impeccable", name]));
if let Some(Value::Object(o)) = raw {
if let Some(Value::Object(det)) = o.get("detector") {
configured.extend(normalize_extension_entries(det.get("extensions")));
}
}
}
let mut out: Vec<String> = LIVE_TEMPLATE_EXTENSIONS
.iter()
.map(|s| s.to_string())
.collect();
for ext in configured {
if out.contains(&ext) {
continue;
}
out.push(ext);
}
out
}
/// JS: matchesTemplateExtension(filePath, extensions)
pub fn matches_template_extension(file_path: &str, extensions: &[String]) -> bool {
let name = jsp::basename(file_path).to_lowercase();
if name.is_empty() {
return false;
}
let name_len = name.encode_utf16().count();
for ext in extensions {
let ext_len = ext.encode_utf16().count();
if name_len > ext_len && name.ends_with(ext.as_str()) {
return true;
}
}
false
}
/// JS: isGeneratedFile(filePath, { cwd })
pub fn is_generated_file(file_path: &str, cwd: &str) -> bool {
let abs = if jsp::is_absolute(file_path) {
file_path.to_string()
} else {
jsp::resolve(cwd, &[file_path])
};
if is_git_ignored(&abs, cwd) {
return true;
}
has_generated_header(&abs)
}
fn is_git_ignored(abs: &str, cwd: &str) -> bool {
let mut cmd = std::process::Command::new("git");
cmd.args(["check-ignore", "--quiet", abs])
.current_dir(cwd)
.stdin(std::process::Stdio::null())
.stdout(std::process::Stdio::null())
.stderr(std::process::Stdio::null());
impeccable_common::proc::hide_window(&mut cmd);
let status = cmd.status();
matches!(status, Ok(s) if s.success())
}
static HEADER_MARKERS: Lazy<Vec<Regex>> = Lazy::new(|| {
vec![
Regex::new(r"(?i)@generated(?-u:\b)").unwrap(),
Regex::new(&format!(
r"(?-u:\b)GENERATED{}+FILE(?-u:\b)",
impeccable_core::js::WS
))
.unwrap(),
Regex::new(r"(?i)(?-u:\b)AUTO-?GENERATED(?-u:\b)").unwrap(),
Regex::new(&format!(
r"(?i)(?-u:\b)DO{ws}+NOT{ws}+EDIT(?-u:\b)",
ws = impeccable_core::js::WS
))
.unwrap(),
]
});
fn has_generated_header(abs: &str) -> bool {
use std::io::Read;
let Ok(mut f) = std::fs::File::open(abs) else {
return false;
};
let mut buf = vec![0u8; 300];
let mut read = 0;
loop {
match f.read(&mut buf[read..]) {
Ok(0) => break,
Ok(n) => {
read += n;
if read >= 300 {
break;
}
}
Err(_) => return false,
}
}
let head = String::from_utf8_lossy(&buf[..read]);
HEADER_MARKERS.iter().any(|re| re.is_match(&head))
}
/// JS: findSourceFile({ query, cwd, extensions, skipDirs, fileFilter }).
/// Returns the absolute path of the first template file whose contents
/// include `query`.
pub fn find_source_file(
query: &str,
cwd: &str,
extensions: &[String],
skip_dirs: &[&str],
file_filter: &dyn Fn(&str) -> bool,
) -> Option<String> {
let mut seen: Vec<String> = Vec::new();
for dir in SOURCE_SEARCH_DIRS {
let abs_dir = jsp::join(&[cwd, dir]);
if !exists(&abs_dir) {
continue;
}
if let Some(r) = walk(
&abs_dir,
query,
extensions,
skip_dirs,
file_filter,
&mut seen,
0,
) {
return Some(r);
}
}
None
}
fn walk(
dir: &str,
query: &str,
extensions: &[String],
skip: &[&str],
file_filter: &dyn Fn(&str) -> bool,
seen: &mut Vec<String>,
depth: usize,
) -> Option<String> {
if depth > MAX_DEPTH {
return None;
}
let real = std::fs::canonicalize(dir).ok()?;
let real = real.to_string_lossy().into_owned();
if seen.contains(&real) {
return None;
}
seen.push(real);
let entries = read_dir_sorted(dir)?;
for entry in &entries {
if !entry.is_file {
continue;
}
if !matches_template_extension(&entry.name, extensions) {
continue;
}
let file_path = jsp::join(&[dir, &entry.name]);
if !file_filter(&file_path) {
continue;
}
if let Some(text) = safe_read(&file_path) {
if text.contains(query) {
return Some(file_path);
}
}
}
for entry in &entries {
if !entry.is_dir {
continue;
}
if skip.contains(&entry.name.as_str()) {
continue;
}
let sub = jsp::join(&[dir, &entry.name]);
if !is_dir(&sub) {
continue;
}
if let Some(r) = walk(&sub, query, extensions, skip, file_filter, seen, depth + 1) {
return Some(r);
}
}
None
}