pub name: String,

pub version: Option<String>,

pub edition: Option<String>,

pub package_manager: Option<String>,

pub main_dependencies: Vec<String>,

pub dev_dependencies: Vec<String>,

pub confidence: f32,

pub source_files: Vec<PathBuf>,

pub manifest_files: Vec<PathBuf>,

files: &[PathBuf],

config: &AnalysisConfig,

) -> Result<Vec<DetectedLanguage>> {

let mut language_info = HashMap::new();

// First pass: collect files by extension and find manifests

let mut source_files_by_lang = HashMap::new();

let mut manifest_files = Vec::new();

for file in files {

if let Some(extension) = file.extension().and_then(|e| e.to_str()) {

match extension {

// Rust files

"rs" => source_files_by_lang

.entry("rust")

.or_insert_with(Vec::new)

.push(file.clone()),

// JavaScript/TypeScript files

"js" | "jsx" | "ts" | "tsx" | "mjs" | "cjs" => source_files_by_lang

.entry("javascript")

.or_insert_with(Vec::new)

.push(file.clone()),

// Python files

"py" | "pyx" | "pyi" => source_files_by_lang

.entry("python")

.or_insert_with(Vec::new)

.push(file.clone()),

// Go files

"go" => source_files_by_lang

.entry("go")

.or_insert_with(Vec::new)

.push(file.clone()),

// Java/Kotlin files

"java" | "kt" | "kts" => source_files_by_lang

.entry("jvm")

.or_insert_with(Vec::new)

.push(file.clone()),

_ => {}

}

}

// Check for manifest files

if let Some(filename) = file.file_name().and_then(|n| n.to_str())

&& is_manifest_file(filename)

{

manifest_files.push(file.clone());

}

}

// Second pass: analyze each detected language with manifest parsing

if (source_files_by_lang.contains_key("rust") || has_manifest(&manifest_files, &["Cargo.toml"]))

&& let Ok(info) =

analyze_rust_project(&manifest_files, source_files_by_lang.get("rust"), config)

{

language_info.insert("rust", info);

}

if (source_files_by_lang.contains_key("javascript")

|| has_manifest(&manifest_files, &["package.json"]))

&& let Ok(info) = analyze_javascript_project(

&manifest_files,

source_files_by_lang.get("javascript"),

config,

)

{

language_info.insert("javascript", info);

}

if (source_files_by_lang.contains_key("python")

|| has_manifest(

&manifest_files,

&["requirements.txt", "Pipfile", "pyproject.toml", "setup.py"],

))

&& let Ok(info) =

analyze_python_project(&manifest_files, source_files_by_lang.get("python"), config)

{

language_info.insert("python", info);

}

if (source_files_by_lang.contains_key("go") || has_manifest(&manifest_files, &["go.mod"]))

&& let Ok(info) =

analyze_go_project(&manifest_files, source_files_by_lang.get("go"), config)

{

language_info.insert("go", info);

}

if (source_files_by_lang.contains_key("jvm")

|| has_manifest(

&manifest_files,

&["pom.xml", "build.gradle", "build.gradle.kts"],

))

&& let Ok(info) =

analyze_jvm_project(&manifest_files, source_files_by_lang.get("jvm"), config)

{

language_info.insert("jvm", info);

}

// Convert to DetectedLanguage format

let mut detected_languages = Vec::new();

for (_, info) in language_info {

detected_languages.push(DetectedLanguage {

name: info.name,

version: info.version,

confidence: info.confidence,

files: info.source_files,

main_dependencies: info.main_dependencies,

dev_dependencies: info.dev_dependencies,

package_manager: info.package_manager,

});

}

// Sort by confidence (highest first)

detected_languages.sort_by(|a, b| {

b.confidence

.partial_cmp(&a.confidence)

.unwrap_or(std::cmp::Ordering::Equal)

});

Ok(detected_languages)

manifest_files: &[PathBuf],

source_files: Option<&Vec<PathBuf>>,

config: &AnalysisConfig,

) -> Result<LanguageInfo> {

let mut info = LanguageInfo {

name: "Rust".to_string(),

version: None,

edition: None,

package_manager: Some("cargo".to_string()),

main_dependencies: Vec::new(),

dev_dependencies: Vec::new(),

confidence: 0.5,

source_files: source_files.map_or(Vec::new(), |f| f.clone()),

manifest_files: Vec::new(),

};

// Find and parse Cargo.toml

for manifest in manifest_files {

if manifest.file_name().and_then(|n| n.to_str()) == Some("Cargo.toml") {

info.manifest_files.push(manifest.clone());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

&& let Ok(cargo_toml) = toml::from_str::<toml::Value>(&content)

{

// Extract edition

if let Some(package) = cargo_toml.get("package")

&& let Some(edition) = package.get("edition").and_then(|e| e.as_str())

{

info.edition = Some(edition.to_string());

}

// Estimate Rust version from edition

info.version = match info.edition.as_deref() {

Some("2021") => Some("1.56+".to_string()),

Some("2018") => Some("1.31+".to_string()),

Some("2015") => Some("1.0+".to_string()),

_ => Some("unknown".to_string()),

};

// Extract dependencies

if let Some(deps_table) = cargo_toml.get("dependencies").and_then(|d| d.as_table())

{

for (name, _) in deps_table {

info.main_dependencies.push(name.clone());

}

}

// Extract dev dependencies if enabled

if config.include_dev_dependencies

&& let Some(dev_deps_table) = cargo_toml

.get("dev-dependencies")

.and_then(|d| d.as_table())

{

for (name, _) in dev_deps_table {

info.dev_dependencies.push(name.clone());

}

}

info.confidence = 0.95; // High confidence with manifest

}

break;

}

}

// Boost confidence if we have source files

if !info.source_files.is_empty() {

info.confidence = (info.confidence + 0.9) / 2.0;

}

Ok(info)

manifest_files: &[PathBuf],

source_files: Option<&Vec<PathBuf>>,

config: &AnalysisConfig,

) -> Result<LanguageInfo> {

let mut info = LanguageInfo {

name: "JavaScript/TypeScript".to_string(),

version: None,

edition: None,

package_manager: None,

main_dependencies: Vec::new(),

dev_dependencies: Vec::new(),

confidence: 0.5,

source_files: source_files.map_or(Vec::new(), |f| f.clone()),

manifest_files: Vec::new(),

};

// Detect package manager from lock files

for manifest in manifest_files {

if let Some(filename) = manifest.file_name().and_then(|n| n.to_str()) {

match filename {

"package-lock.json" => info.package_manager = Some("npm".to_string()),

"yarn.lock" => info.package_manager = Some("yarn".to_string()),

"pnpm-lock.yaml" => info.package_manager = Some("pnpm".to_string()),

_ => {}

}

}

}

// Default to npm if no package manager detected

if info.package_manager.is_none() {

info.package_manager = Some("npm".to_string());

}

// Find and parse package.json

for manifest in manifest_files {

if manifest.file_name().and_then(|n| n.to_str()) == Some("package.json") {

info.manifest_files.push(manifest.clone());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

&& let Ok(package_json) = serde_json::from_str::<JsonValue>(&content)

{

// Extract Node.js version from engines

if let Some(node_version) = package_json

.get("engines")

.and_then(|e| e.get("node"))

.and_then(|v| v.as_str())

{

info.version = Some(node_version.to_string());

}

// Extract dependencies (always include all buckets for framework detection)

if let Some(deps) = package_json.get("dependencies").and_then(|d| d.as_object()) {

for (name, _) in deps {

info.main_dependencies.push(name.clone());

}

}

// Frameworks like Vite/Remix/Next are often in devDependencies; always include

if let Some(dev_deps) = package_json

.get("devDependencies")

.and_then(|d| d.as_object())

{

for (name, _) in dev_deps {

info.main_dependencies.push(name.clone());

info.dev_dependencies.push(name.clone());

}

}

// peerDependencies frequently carry framework identity (e.g., react-router)

if let Some(peer_deps) = package_json

.get("peerDependencies")

.and_then(|d| d.as_object())

{

for (name, _) in peer_deps {

info.main_dependencies.push(name.clone());

}

}

// optional/bundled deps can also hold framework markers (rare but cheap to add)

if let Some(opt_deps) = package_json

.get("optionalDependencies")

.and_then(|d| d.as_object())

{

for (name, _) in opt_deps {

info.main_dependencies.push(name.clone());

}

}

if let Some(bundle_deps) = package_json

.get("bundledDependencies")

.and_then(|d| d.as_array())

{

for dep in bundle_deps.iter().filter_map(|d| d.as_str()) {

info.main_dependencies.push(dep.to_string());

}

}

info.confidence = 0.95; // High confidence with manifest

}

break;

}

}

// Adjust name based on file types

if let Some(files) = source_files {

let has_typescript = files.iter().any(|f| {

f.extension()

.and_then(|e| e.to_str())

.is_some_and(|ext| ext == "ts" || ext == "tsx")

});

if has_typescript {

info.name = "TypeScript".to_string();

} else {

info.name = "JavaScript".to_string();

}

}

// Boost confidence if we have source files

if !info.source_files.is_empty() {

info.confidence = (info.confidence + 0.9) / 2.0;

}

Ok(info)

manifest_files: &[PathBuf],

source_files: Option<&Vec<PathBuf>>,

config: &AnalysisConfig,

) -> Result<LanguageInfo> {

let mut info = LanguageInfo {

name: "Python".to_string(),

version: None,

edition: None,

package_manager: None,

main_dependencies: Vec::new(),

dev_dependencies: Vec::new(),

confidence: 0.5,

source_files: source_files.map_or(Vec::new(), |f| f.clone()),

manifest_files: Vec::new(),

};

// Detect package manager and parse manifest files

for manifest in manifest_files {

if let Some(filename) = manifest.file_name().and_then(|n| n.to_str()) {

info.manifest_files.push(manifest.clone());

match filename {

"requirements.txt" => {

info.package_manager = Some("pip".to_string());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

{

parse_requirements_txt(&content, &mut info);

info.confidence = 0.85;

}

}

"Pipfile" => {

info.package_manager = Some("pipenv".to_string());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

{

parse_pipfile(&content, &mut info, config);

info.confidence = 0.90;

}

}

"pyproject.toml" => {

info.package_manager = Some("poetry/pip".to_string());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

{

parse_pyproject_toml(&content, &mut info, config);

info.confidence = 0.95;

}

}

"setup.py" => {

info.package_manager = Some("setuptools".to_string());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

{

parse_setup_py(&content, &mut info);

info.confidence = 0.80;

}

}

_ => {}

}

}

}

// Default to pip if no package manager detected

if info.package_manager.is_none() && !info.source_files.is_empty() {

info.package_manager = Some("pip".to_string());

info.confidence = 0.75;

}

// Boost confidence if we have source files

if !info.source_files.is_empty() {

info.confidence = (info.confidence + 0.8) / 2.0;

}

Ok(info)

for line in content.lines() {

let line = line.trim();

if line.is_empty() || line.starts_with('#') {

continue;

}

// Extract package name (before ==, >=, etc.)

if let Some(package_name) = line.split(&['=', '>', '<', '!', '~', ';'][..]).next() {

let clean_name = package_name.trim();

if !clean_name.is_empty() && !clean_name.starts_with('-') {

info.main_dependencies.push(clean_name.to_string());

}

}

}

if let Ok(pipfile) = toml::from_str::<toml::Value>(content) {

// Extract Python version requirement

if let Some(requires) = pipfile.get("requires") {

if let Some(python_version) = requires.get("python_version").and_then(|v| v.as_str()) {

info.version = Some(format!("~={}", python_version));

} else if let Some(python_full) =

requires.get("python_full_version").and_then(|v| v.as_str())

{

info.version = Some(format!("=={}", python_full));

}

}

// Extract packages

if let Some(packages_table) = pipfile.get("packages").and_then(|p| p.as_table()) {

for (name, _) in packages_table {

info.main_dependencies.push(name.clone());

}

}

// Extract dev packages if enabled

if config.include_dev_dependencies

&& let Some(dev_packages_table) = pipfile.get("dev-packages").and_then(|d| d.as_table())

{

for (name, _) in dev_packages_table {

info.dev_dependencies.push(name.clone());

}

}

}

if let Ok(pyproject) = toml::from_str::<toml::Value>(content) {

// Extract Python version from project metadata

if let Some(project) = pyproject.get("project") {

if let Some(requires_python) = project.get("requires-python").and_then(|v| v.as_str()) {

info.version = Some(requires_python.to_string());

}

// Extract dependencies

if let Some(deps_array) = project.get("dependencies").and_then(|d| d.as_array()) {

for dep in deps_array {

if let Some(dep_str) = dep.as_str()

&& let Some(package_name) =

dep_str.split(&['=', '>', '<', '!', '~', ';'][..]).next()

{

let clean_name = package_name.trim();

if !clean_name.is_empty() {

info.main_dependencies.push(clean_name.to_string());

}

}

}

}

// Extract optional dependencies (dev dependencies)

if config.include_dev_dependencies

&& let Some(optional_table) = project

.get("optional-dependencies")

.and_then(|o| o.as_table())

{

for (_, deps) in optional_table {

if let Some(deps_array) = deps.as_array() {

for dep in deps_array {

if let Some(dep_str) = dep.as_str()

&& let Some(package_name) =

dep_str.split(&['=', '>', '<', '!', '~', ';'][..]).next()

{

let clean_name = package_name.trim();

if !clean_name.is_empty() {

info.dev_dependencies.push(clean_name.to_string());

}

}

}

}

}

}

}

// Check for Poetry configuration

if let Some(poetry) = pyproject.get("tool").and_then(|t| t.get("poetry")) {

info.package_manager = Some("poetry".to_string());

// Extract Poetry dependencies

if let Some(deps_table) = poetry.get("dependencies").and_then(|d| d.as_table()) {

for (name, _) in deps_table {

if name != "python" {

info.main_dependencies.push(name.clone());

}

}

}

if config.include_dev_dependencies

&& let Some(dev_deps_table) = poetry

.get("group")

.and_then(|g| g.get("dev"))

.and_then(|d| d.get("dependencies"))

.and_then(|d| d.as_table())

{

for (name, _) in dev_deps_table {

info.dev_dependencies.push(name.clone());

}

}

}

}

// Basic regex-based parsing for common patterns

for line in content.lines() {

let line = line.trim();

// Look for python_requires

if line.contains("python_requires") {

if let Some(start) = line.find('"')

&& let Some(end) = line[start + 1..].find('"')

{

let version = &line[start + 1..start + 1 + end];

info.version = Some(version.to_string());

} else if let Some(start) = line.find('\'')

&& let Some(end) = line[start + 1..].find('\'')

{

let version = &line[start + 1..start + 1 + end];

info.version = Some(version.to_string());

}

}

// Look for install_requires (basic pattern)

if line.contains("install_requires") && line.contains("[") {

// This is a simplified parser - could be enhanced

info.main_dependencies

.push("setuptools-detected".to_string());

}

}

manifest_files: &[PathBuf],

source_files: Option<&Vec<PathBuf>>,

config: &AnalysisConfig,

) -> Result<LanguageInfo> {

let mut info = LanguageInfo {

name: "Go".to_string(),

version: None,

edition: None,

package_manager: Some("go mod".to_string()),

main_dependencies: Vec::new(),

dev_dependencies: Vec::new(),

confidence: 0.5,

source_files: source_files.map_or(Vec::new(), |f| f.clone()),

manifest_files: Vec::new(),

};

// Find and parse go.mod

for manifest in manifest_files {

if let Some(filename) = manifest.file_name().and_then(|n| n.to_str()) {

match filename {

"go.mod" => {

info.manifest_files.push(manifest.clone());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

{

parse_go_mod(&content, &mut info);

info.confidence = 0.95;

}

}

"go.sum" => {

info.manifest_files.push(manifest.clone());

// go.sum contains checksums, indicates a real Go project

info.confidence = (info.confidence + 0.9) / 2.0;

}

_ => {}

}

}

}

// Boost confidence if we have source files

if !info.source_files.is_empty() {

info.confidence = (info.confidence + 0.85) / 2.0;

}

Ok(info)

for line in content.lines() {

let line = line.trim();

// Parse go version directive

if let Some(version) = line.strip_prefix("go ") {

info.version = Some(version.trim().to_string());

}

// Parse require block

if let Some(require_line) = line.strip_prefix("require ") {

// Single line require

let require_line = require_line.trim();

if let Some(module_name) = require_line.split_whitespace().next() {

info.main_dependencies.push(module_name.to_string());

}

}

}

// Parse multi-line require blocks

let mut in_require_block = false;

for line in content.lines() {

let line = line.trim();

if line == "require (" {

in_require_block = true;

continue;

}

if in_require_block {

if line == ")" {

in_require_block = false;

continue;

}

// Parse dependency line

if !line.is_empty()

&& !line.starts_with("//")

&& let Some(module_name) = line.split_whitespace().next()

{

info.main_dependencies.push(module_name.to_string());

}

}

}

manifest_files: &[PathBuf],

source_files: Option<&Vec<PathBuf>>,

config: &AnalysisConfig,

) -> Result<LanguageInfo> {

let mut info = LanguageInfo {

name: "Java/Kotlin".to_string(),

version: None,

edition: None,

package_manager: None,

main_dependencies: Vec::new(),

dev_dependencies: Vec::new(),

confidence: 0.5,

source_files: source_files.map_or(Vec::new(), |f| f.clone()),

manifest_files: Vec::new(),

};

// Detect build tool and parse manifest files

for manifest in manifest_files {

if let Some(filename) = manifest.file_name().and_then(|n| n.to_str()) {

info.manifest_files.push(manifest.clone());

match filename {

"pom.xml" => {

info.package_manager = Some("maven".to_string());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

{

parse_maven_pom(&content, &mut info, config);

info.confidence = 0.90;

}

}

"build.gradle" => {

info.package_manager = Some("gradle".to_string());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

{

parse_gradle_build(&content, &mut info, config);

info.confidence = 0.85;

}

}

"build.gradle.kts" => {

info.package_manager = Some("gradle".to_string());

if let Ok(content) = file_utils::read_file_safe(manifest, config.max_file_size)

{

parse_gradle_kts_build(&content, &mut info, config);

info.confidence = 0.85;

}

}

_ => {}

}

}

}

// Adjust name based on file types

if let Some(files) = source_files {

let has_kotlin = files.iter().any(|f| {

f.extension()

.and_then(|e| e.to_str())

.is_some_and(|ext| ext == "kt" || ext == "kts")

});

if has_kotlin {

info.name = "Kotlin".to_string();

} else {

info.name = "Java".to_string();

}

}

// Boost confidence if we have source files

if !info.source_files.is_empty() {

info.confidence = (info.confidence + 0.8) / 2.0;

}

Ok(info)

// Simple regex-based XML parsing for common Maven patterns

// Extract Java version from maven.compiler.source or java.version

for line in content.lines() {

let line = line.trim();

// Look for Java version in properties

if line.contains("<maven.compiler.source>")

&& let Some(version) = extract_xml_content(line, "maven.compiler.source")

{

info.version = Some(version);

} else if line.contains("<java.version>")

&& let Some(version) = extract_xml_content(line, "java.version")

{

info.version = Some(version);

} else if line.contains("<maven.compiler.target>")

&& info.version.is_none()

&& let Some(version) = extract_xml_content(line, "maven.compiler.target")

{

info.version = Some(version);

}

// Extract dependencies

if line.contains("<groupId>")

&& line.contains("<artifactId>")

&& let Some(group_id) = extract_xml_content(line, "groupId")

&& let Some(artifact_id) = extract_xml_content(line, "artifactId")

{

// This is a simplified approach - real XML parsing would be better

let dependency = format!("{}:{}", group_id, artifact_id);

info.main_dependencies.push(dependency);

} else if line.contains("<artifactId>")

&& !line.contains("<groupId>")

&& let Some(artifact_id) = extract_xml_content(line, "artifactId")

{

info.main_dependencies.push(artifact_id);

}

}

// Look for dependencies in a more structured way

let mut in_dependencies = false;

let mut in_test_dependencies = false;

for line in content.lines() {

let line = line.trim();

if line.contains("<dependencies>") {

in_dependencies = true;

continue;

}

if line.contains("</dependencies>") {

in_dependencies = false;

in_test_dependencies = false;

continue;

}

if in_dependencies && line.contains("<scope>test</scope>") {

in_test_dependencies = true;

}

if in_dependencies

&& line.contains("<artifactId>")

&& let Some(artifact_id) = extract_xml_content(line, "artifactId")

{

if in_test_dependencies && config.include_dev_dependencies {

info.dev_dependencies.push(artifact_id);

} else if !in_test_dependencies {

info.main_dependencies.push(artifact_id);

}

}

}

for line in content.lines() {

let line = line.trim();

// Look for Java version

if (line.contains("sourceCompatibility") || line.contains("targetCompatibility"))

&& let Some(version) = extract_gradle_version(line)

{

info.version = Some(version);

} else if line.contains("JavaVersion.VERSION_")

&& let Some(pos) = line.find("VERSION_")

{

let version_part = &line[pos + 8..];

if let Some(end) = version_part.find(|c: char| !c.is_numeric() && c != '_') {

let version = &version_part[..end].replace('_', ".");

info.version = Some(version.to_string());

}

}

// Look for dependencies

if (line.starts_with("implementation ") || line.starts_with("compile "))

&& let Some(dep) = extract_gradle_dependency(line)

{

info.main_dependencies.push(dep);

} else if (line.starts_with("testImplementation ") || line.starts_with("testCompile "))

&& config.include_dev_dependencies

&& let Some(dep) = extract_gradle_dependency(line)