use std::path::{Path, PathBuf};
use std::sync::Arc;
use anyhow::Result;
use serde_json::json;
use crate::db::graph::{GraphDb, QueryExt};
use crate::models::RepoScope;
const MAX_FILES: usize = 2000;
const MAX_SCAN_PAGES: usize = 64;
pub fn normalize_list_path(path: &str, cwd: Option<&Path>, repo_root: Option<&Path>) -> String {
super::explore_file::normalize_explore_input(path, repo_root)
.pipe(|normalized| resolve_against_disk(path, cwd, repo_root, normalized))
}
trait Pipe: Sized {
fn pipe<T>(self, f: impl FnOnce(Self) -> T) -> T {
f(self)
}
}
impl<T> Pipe for T {}
fn resolve_against_disk(
raw: &str,
cwd: Option<&Path>,
repo_root: Option<&Path>,
normalized: String,
) -> String {
let resolved = super::explore_file::resolve_explore_input(raw, cwd, repo_root);
if resolved.len() < raw.len() && !resolved.is_empty() {
resolved
} else {
normalized
}
}
pub fn path_matches(prefix: &str, candidate: &str) -> bool {
let p = prefix.trim_matches('/');
if p.is_empty() || p == "." {
return true;
}
if p.contains('*') || p.contains('?') {
return glob_match(p, candidate);
}
candidate == p || candidate.starts_with(&format!("{p}/"))
}
pub fn glob_match(pattern: &str, candidate: &str) -> bool {
let p_segs: Vec<&str> = pattern.split('/').filter(|s| !s.is_empty()).collect();
let c_segs: Vec<&str> = candidate.split('/').filter(|s| !s.is_empty()).collect();
segments_match(&p_segs, &c_segs)
}
fn segments_match(p: &[&str], c: &[&str]) -> bool {
match p.first() {
None => c.is_empty(),
Some(&"**") => {
for skip in 0..=c.len() {
if segments_match(&p[1..], &c[skip..]) {
return true;
}
}
false
}
Some(&first) => {
if c.is_empty() || !segment_match(first, c[0]) {
return false;
}
segments_match(&p[1..], &c[1..])
}
}
}
fn segment_match(pattern: &str, segment: &str) -> bool {
let p: Vec<char> = pattern.chars().collect();
let s: Vec<char> = segment.chars().collect();
let (mut pi, mut si) = (0usize, 0usize);
let mut star: Option<(usize, usize)> = None;
while si < s.len() {
if pi < p.len() {
match p[pi] {
'*' => {
star = Some((pi, si));
pi += 1;
continue;
}
'?' => {
pi += 1;
si += 1;
continue;
}
ch if ch == s[si] => {
pi += 1;
si += 1;
continue;
}
_ => {}
}
}
match star {
Some((re_pi, advanced_si)) => {
pi = re_pi + 1;
si = advanced_si + 1;
star = Some((re_pi, advanced_si + 1));
}
None => return false,
}
}
while pi < p.len() && p[pi] == '*' {
pi += 1;
}
pi == p.len()
}
pub fn format_list_files_markdown(files: &serde_json::Value) -> String {
let rows = files
.get("files")
.or_else(|| files.as_array().map(|_| files))
.and_then(|v| v.as_array())
.map(Vec::as_slice)
.unwrap_or(&[]);
if rows.is_empty() {
return "No indexed files matched the given path.".to_string();
}
let mut out = String::from("| Repository | File | Entities |\n|---|---|---:|\n");
for row in rows {
let repo = row.get("repo_name").and_then(|v| v.as_str()).unwrap_or("?");
let file = row.get("file_path").and_then(|v| v.as_str()).unwrap_or("?");
let count = row
.get("entity_count")
.and_then(|v| v.as_i64())
.unwrap_or(0);
out.push_str(&format!("| {repo} | {file} | {count} |\n"));
}
let is_truncated = files
.get("truncated")
.and_then(|v| v.as_bool())
.unwrap_or(false);
if is_truncated {
let shown = rows.len();
let exact = files
.get("total_matches")
.and_then(serde_json::Value::as_u64)
.filter(|_| {
!files
.get("total_is_lower_bound")
.and_then(serde_json::Value::as_bool)
.unwrap_or(true)
});
match exact {
Some(total) => out.push_str(&format!(
"\nShowing first {shown} of {total} files (truncated) โ narrow the pattern."
)),
None => out.push_str(&format!(
"\nShowing first {shown} of more than {shown} files (truncated) โ narrow the pattern."
)),
}
}
out
}
pub fn format_files_output(
result: &serde_json::Value,
output: crate::config::OutputFormat,
) -> String {
super::format_json_or_markdown(result, output, format_list_files_markdown)
}
struct ScanOutcome {
rows: Vec<serde_json::Value>,
exhausted: bool,
}
struct ScanParams<'a> {
query_prefix: &'a str,
filter: &'a str,
repo_names: &'a [String],
page_size: usize,
stop_after: usize,
}
async fn scan_matching_files<F, Fut>(fetch_page: F, params: ScanParams<'_>) -> Result<ScanOutcome>
where
F: Fn(String, Vec<String>, usize, usize) -> Fut,
Fut: Future<Output = Result<serde_json::Value>>,
{
let mut rows: Vec<serde_json::Value> = Vec::new();
let mut skip = 0usize;
let mut exhausted = false;
for _ in 0..MAX_SCAN_PAGES {
let page = fetch_page(
params.query_prefix.to_string(),
params.repo_names.to_vec(),
skip,
params.page_size,
)
.await?;
let page_arr = page.as_array().cloned().unwrap_or_default();
let fetched_len = page_arr.len();
rows.extend(page_arr.into_iter().filter(|row| {
let candidate = row.get("file_path").and_then(|v| v.as_str()).unwrap_or("");
path_matches(params.filter, candidate)
}));
if fetched_len < params.page_size {
exhausted = true;
break;
}
if rows.len() >= params.stop_after {
rows.truncate(params.stop_after);
break;
}
skip += params.page_size;
}
Ok(ScanOutcome { rows, exhausted })
}
pub async fn run_list_files(
path: Option<&str>,
repo: &RepoScope,
graph_db: &Arc<GraphDb>,
) -> Result<serde_json::Value> {
run_list_files_with_fetcher(path, repo, |prefix, repo_names, skip, limit| async move {
graph_db.list_files(&prefix, &repo_names, skip, limit).await
})
.await
}
async fn run_list_files_with_fetcher<F, Fut>(
path: Option<&str>,
repo: &RepoScope,
fetch_page: F,
) -> Result<serde_json::Value>
where
F: Fn(String, Vec<String>, usize, usize) -> Fut,
Fut: Future<Output = Result<serde_json::Value>>,
{
let cwd = std::env::current_dir().ok();
let repo_root = std::env::var("KNOT_REPO_PATH").ok().map(PathBuf::from);
let normalized = path
.filter(|p| !p.trim().is_empty())
.map(|p| normalize_list_path(p, cwd.as_deref(), repo_root.as_deref()))
.unwrap_or_default();
let repo_names = repo.filter_names();
let is_glob = normalized.contains('*') || normalized.contains('?');
let query_prefix = if is_glob { "" } else { normalized.as_str() };
let scan = scan_matching_files(
&fetch_page,
ScanParams {
query_prefix,
filter: &normalized,
repo_names: &repo_names,
page_size: MAX_FILES,
stop_after: MAX_FILES + 1,
},
)
.await?;
if scan.rows.is_empty() {
return Ok(serde_json::Value::Null);
}
let total_matches = scan.rows.len();
let is_truncated = total_matches > MAX_FILES || !scan.exhausted;
let mut final_files = scan.rows;
final_files.truncate(MAX_FILES);
Ok(json!({
"files": final_files,
"truncated": is_truncated,
"total_matches": total_matches,
"total_is_lower_bound": !scan.exhausted,
}))
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn normalize_list_path_posix() {
assert_eq!(normalize_list_path("src/api", None, None), "src/api");
assert_eq!(normalize_list_path("./src/api", None, None), "src/api");
assert_eq!(normalize_list_path(r"src\api", None, None), "src/api");
assert_eq!(normalize_list_path("", None, None), "");
}
#[test]
fn normalize_list_path_strips_local_root() {
let root = Path::new("/home/dev/repo");
assert_eq!(
normalize_list_path("/home/dev/repo/src/api", Some(root), Some(root)),
"src/api"
);
}
#[test]
fn empty_prefix_matches_everything() {
assert!(path_matches("", "src/main.rs"));
assert!(path_matches(".", "Cargo.toml"));
}
#[test]
fn boundary_prefix_respects_directory_edges() {
assert!(path_matches("src/api", "src/api/users.ts"));
assert!(path_matches("src/api", "src/api"));
assert!(!path_matches("src/api", "src/api-notes.md"));
assert!(!path_matches("src/api", "src/hooks/useThing.ts"));
}
#[test]
fn glob_star_is_segment_local() {
assert!(glob_match("src/*.rs", "src/main.rs"));
assert!(!glob_match("src/*.rs", "src/cli/main.rs"));
assert!(glob_match("*/tests/*.ts", "hooks/tests/a.ts"));
}
#[test]
fn glob_double_star_crosses_segments() {
assert!(glob_match("src/**", "src/api/v1/users.ts"));
assert!(glob_match("src/**/*.rs", "src/cli_tools/x/tests/a.rs"));
assert!(glob_match("src/**", "src"));
}
#[test]
fn glob_question_mark_is_single_non_slash() {
assert!(glob_match("a?.rs", "ab.rs"));
assert!(!glob_match("a?.rs", "abc.rs"));
}
#[test]
fn markdown_table_lists_repo_file_count() {
let files = json!({
"files": [
{"repo_name": "r", "file_path": "src/a.rs", "entity_count": 3},
{"repo_name": "r", "file_path": "src/b.rs", "entity_count": 1},
],
"truncated": false,
});
let md = format_list_files_markdown(&files);
assert!(md.contains("| Repository | File | Entities |"));
assert!(md.contains("| r | src/a.rs | 3 |"));
assert!(md.contains("| r | src/b.rs | 1 |"));
assert!(!md.contains("(truncated)"));
}
#[test]
fn markdown_table_renders_exact_truncated_notice() {
let files = json!({
"files": [
{"repo_name": "r", "file_path": "src/a.rs", "entity_count": 3},
{"repo_name": "r", "file_path": "src/b.rs", "entity_count": 1},
],
"truncated": true,
"total_matches": 3471,
"total_is_lower_bound": false,
});
let md = format_list_files_markdown(&files);
assert!(md.contains("| Repository | File | Entities |"));
assert!(md.contains("| r | src/a.rs | 3 |"));
assert!(md.contains("| r | src/b.rs | 1 |"));
assert!(md.contains("Showing first 2 of 3471 files (truncated) โ narrow the pattern."));
}
#[test]
fn markdown_table_renders_lower_bound_notice() {
let files = json!({
"files": [
{"repo_name": "r", "file_path": "src/a.rs", "entity_count": 3},
{"repo_name": "r", "file_path": "src/b.rs", "entity_count": 1},
],
"truncated": true,
"total_matches": 2,
"total_is_lower_bound": true,
});
let md = format_list_files_markdown(&files);
assert!(
md.contains("Showing first 2 of more than 2 files (truncated) โ narrow the pattern.")
);
assert!(!md.contains("of at least 3"));
}
#[test]
fn markdown_empty_list_hits_the_no_match_message() {
let md = format_list_files_markdown(&json!([]));
assert!(md.contains("No indexed files matched"));
}
#[tokio::test]
async fn plain_prefix_behind_many_non_matching_siblings_pages_and_returns_matches() {
let mut mock_files = Vec::new();
for i in 0..2400 {
mock_files.push(json!({
"repo_name": "repo",
"file_path": format!("src/api-notes/f{i}.md"),
"entity_count": 1,
}));
}
for i in 0..5 {
mock_files.push(json!({
"repo_name": "repo",
"file_path": format!("src/api/users{i}.ts"),
"entity_count": 2,
}));
}
let repo_scope = RepoScope::All;
let res = run_list_files_with_fetcher(
Some("src/api"),
&repo_scope,
|prefix, _repo_names, skip, limit| {
let mock_files = mock_files.clone();
async move {
let filtered: Vec<serde_json::Value> = mock_files
.into_iter()
.filter(|f| {
let path = f.get("file_path").and_then(|v| v.as_str()).unwrap_or("");
path.starts_with(&prefix)
})
.skip(skip)
.take(limit)
.collect();
Ok(json!(filtered))
}
},
)
.await
.unwrap();
let files = res.get("files").and_then(|v| v.as_array()).unwrap();
assert_eq!(files.len(), 5);
for f in files {
let path = f.get("file_path").and_then(|v| v.as_str()).unwrap();
assert!(path.starts_with("src/api/"));
}
assert_eq!(res.get("truncated").and_then(|v| v.as_bool()), Some(false));
assert_eq!(res.get("total_matches").and_then(|v| v.as_u64()), Some(5));
assert_eq!(
res.get("total_is_lower_bound").and_then(|v| v.as_bool()),
Some(false)
);
}
#[tokio::test]
async fn plain_prefix_with_unfiltered_overflow_but_filtered_under_cap_reports_not_truncated() {
let mut mock_files = Vec::new();
for i in 0..3000 {
mock_files.push(json!({
"repo_name": "repo",
"file_path": format!("src/api-notes/f{i}.md"),
"entity_count": 1,
}));
}
for i in 0..10 {
mock_files.push(json!({
"repo_name": "repo",
"file_path": format!("src/api/x{i}.ts"),
"entity_count": 2,
}));
}
let repo_scope = RepoScope::All;
let res = run_list_files_with_fetcher(
Some("src/api"),
&repo_scope,
|prefix, _repo_names, skip, limit| {
let mock_files = mock_files.clone();
async move {
let filtered: Vec<serde_json::Value> = mock_files
.into_iter()
.filter(|f| {
let path = f.get("file_path").and_then(|v| v.as_str()).unwrap_or("");
path.starts_with(&prefix)
})
.skip(skip)
.take(limit)
.collect();
Ok(json!(filtered))
}
},
)
.await
.unwrap();
let files = res.get("files").and_then(|v| v.as_array()).unwrap();
assert_eq!(files.len(), 10);
assert_eq!(res.get("truncated").and_then(|v| v.as_bool()), Some(false));
}
#[tokio::test]
async fn pager_terminates_at_max_scan_pages_when_fetcher_ignores_skip() {
use std::time::Duration;
let repo_scope = RepoScope::All;
let res = tokio::time::timeout(
Duration::from_secs(5),
run_list_files_with_fetcher(
Some("auto/**"),
&repo_scope,
|_prefix, _repo_names, _skip, _limit| async move {
let mut page = Vec::new();
page.push(json!({
"repo_name": "repo",
"file_path": "auto/keep.java",
"entity_count": 1,
}));
for i in 0..1999 {
page.push(json!({
"repo_name": "repo",
"file_path": format!("other/f{i}.java"),
"entity_count": 1,
}));
}
Ok(json!(page))
},
),
)
.await
.expect("listing timed out โ pager did not terminate")
.unwrap();
let files = res.get("files").and_then(|v| v.as_array()).unwrap();
assert_eq!(files.len(), MAX_SCAN_PAGES);
assert_eq!(res.get("truncated").and_then(|v| v.as_bool()), Some(true));
assert_eq!(
res.get("total_matches").and_then(|v| v.as_u64()),
Some(MAX_SCAN_PAGES as u64)
);
assert_eq!(
res.get("total_is_lower_bound").and_then(|v| v.as_bool()),
Some(true)
);
}
#[tokio::test]
async fn glob_pages_entire_graph_scope_without_dropping_matches() {
let mut mock_files = Vec::new();
for i in 0..2490 {
mock_files.push(json!({
"repo_name": "spring-ai",
"file_path": format!("core/src/main/java/File{i}.java"),
"entity_count": 1,
}));
}
for i in 0..10 {
mock_files.push(json!({
"repo_name": "spring-ai",
"file_path": format!("auto-configurations/src/main/java/Config{i}.java"),
"entity_count": 2,
}));
}
let repo_scope = RepoScope::All;
let res = run_list_files_with_fetcher(
Some("auto-configurations/**/*.java"),
&repo_scope,
|prefix, _repo_names, skip, limit| {
let mock_files = mock_files.clone();
async move {
let filtered: Vec<serde_json::Value> = mock_files
.into_iter()
.filter(|f| {
let path = f.get("file_path").and_then(|v| v.as_str()).unwrap_or("");
path.starts_with(&prefix)
})
.skip(skip)
.take(limit)
.collect();
Ok(json!(filtered))
}
},
)
.await
.unwrap();
let files = res.get("files").and_then(|v| v.as_array()).unwrap();
assert_eq!(files.len(), 10);
assert_eq!(res.get("truncated").and_then(|v| v.as_bool()), Some(false));
assert_eq!(res.get("total_matches").and_then(|v| v.as_u64()), Some(10));
assert_eq!(
res.get("total_is_lower_bound").and_then(|v| v.as_bool()),
Some(false)
);
}
}