use crate::models::{EntityKind, ParsedEntity, ReferenceIntent};
use crate::utils::identifiers::identifier_token_phrase;
const MAX_CALL_NAMES: usize = 20;
pub fn prepare_entities(entities: &mut [ParsedEntity]) {
for entity in entities.iter_mut() {
if matches!(
entity.kind,
EntityKind::MarkdownSection | EntityKind::MarkdownDocument
) {
continue;
}
entity.embed_text = build_embed_text(entity);
}
}
fn build_embed_text(entity: &ParsedEntity) -> String {
let mut parts: Vec<String> = Vec::with_capacity(10);
parts.push(format!("[{}] {}", entity.kind, entity.name));
let name_phrase = identifier_token_phrase(&entity.name);
if name_phrase != entity.name {
parts.push(format!("Identifier: {name_phrase}"));
}
if !entity.fqn.is_empty() && entity.fqn != entity.name {
parts.push(format!("FQN: {}", entity.fqn));
let fqn_phrase = identifier_token_phrase(&entity.fqn);
if fqn_phrase != name_phrase {
parts.push(format!("Identifier: {fqn_phrase}"));
}
}
if !entity.decorators.is_empty() {
let decorators_text = entity
.decorators
.iter()
.filter(|d| !d.trim().is_empty())
.cloned()
.collect::<Vec<_>>()
.join(", ");
if !decorators_text.is_empty() {
parts.push(format!("Decorators: {}", decorators_text));
}
}
if let Some(sig) = &entity.signature {
parts.push(format!("Signature: {sig}"));
}
if let Some(doc) = &entity.docstring
&& !doc.trim().is_empty()
{
parts.push(doc.trim().to_owned());
}
if !entity.inline_comments.is_empty() {
let inline_text = entity
.inline_comments
.iter()
.filter(|c| !c.trim().is_empty())
.cloned()
.collect::<Vec<_>>()
.join("\n");
if !inline_text.trim().is_empty() {
parts.push(format!("Implementation context:\n{}", inline_text));
}
}
let calls_section = calls_section_text(entity);
if !calls_section.is_empty() {
parts.push(format!("Calls: {calls_section}"));
}
parts.push(format!("File: {}:{}", entity.file_path, entity.start_line));
parts.join("\n")
}
fn calls_section_text(entity: &ParsedEntity) -> String {
let mut seen: Vec<String> = Vec::new();
for intent in &entity.reference_intents {
if seen.len() >= MAX_CALL_NAMES {
break;
}
let name = match intent {
ReferenceIntent::Call { method, .. } => method.as_str(),
ReferenceIntent::TypeReference { type_name, .. } => type_name.as_str(),
ReferenceIntent::Extends { parent, .. } => parent.as_str(),
ReferenceIntent::Implements { interface, .. } => interface.as_str(),
_ => continue,
};
if name == entity.name || name.trim().is_empty() {
continue;
}
if !seen.contains(&name.to_string()) {
seen.push(name.to_string());
}
}
seen.iter()
.map(|n| identifier_token_phrase(n))
.collect::<Vec<_>>()
.join(", ")
}
#[cfg(test)]
mod tests {
use super::*;
use crate::models::ParsedEntity;
#[test]
fn test_build_embed_text_minimal() {
let entity = ParsedEntity::new(
"MyClass",
EntityKind::Class,
"com.example.MyClass",
None,
None,
"java",
"com/example/MyClass.java",
10,
20,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[class] MyClass"));
assert!(embed_text.contains("File: com/example/MyClass.java:10"));
assert!(!embed_text.contains("Signature:"));
assert!(!embed_text.contains("Decorators:"));
}
#[test]
fn test_build_embed_text_full() {
let mut entity = ParsedEntity::new(
"saveUser",
EntityKind::Method,
"UserService.saveUser",
Some("public void saveUser(User user)".to_string()),
Some("Saves a new user to the database.".to_string()),
"java",
"UserService.java",
42,
50,
Some("UserService".to_string()),
"test-repo",
);
entity.decorators = vec!["@Transactional".to_string(), "@Override".to_string()];
entity.inline_comments = vec![
"// Check for duplicates".to_string(),
"/* Commit transaction */".to_string(),
];
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[method] saveUser"));
assert!(embed_text.contains("Signature: public void saveUser(User user)"));
assert!(embed_text.contains("Saves a new user to the database."));
assert!(embed_text.contains("Decorators: @Transactional, @Override"));
assert!(embed_text.contains(
"Implementation context:\n// Check for duplicates\n/* Commit transaction */"
));
assert!(embed_text.contains("File: UserService.java:42"));
}
#[test]
fn test_prepare_entities_batch() {
let entity1 = ParsedEntity::new(
"Class1",
EntityKind::Class,
"Class1",
None,
None,
"java",
"file1.java",
1,
10,
None,
"test-repo",
);
let entity2 = ParsedEntity::new(
"Class2",
EntityKind::Class,
"Class2",
None,
None,
"java",
"file2.java",
1,
10,
None,
"test-repo",
);
let mut entities = vec![entity1, entity2];
assert!(entities[0].embed_text.is_empty());
assert!(entities[1].embed_text.is_empty());
prepare_entities(&mut entities);
assert!(!entities[0].embed_text.is_empty());
assert!(!entities[1].embed_text.is_empty());
assert!(entities[0].embed_text.contains("Class1"));
assert!(entities[1].embed_text.contains("Class2"));
}
#[test]
fn test_build_embed_text_build_dependency() {
let entity = ParsedEntity::new(
"org.springframework:spring-core:5.3.29",
EntityKind::BuildDependency,
"org.springframework:spring-core:5.3.29",
Some("scope: compile".to_string()),
Some("Maven dependency: org.springframework:spring-core:5.3.29".to_string()),
"xml",
"pom.xml",
15,
19,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[build_dependency] org.springframework:spring-core:5.3.29"));
assert!(embed_text.contains("Signature: scope: compile"));
assert!(embed_text.contains("Maven dependency:"));
assert!(embed_text.contains("File: pom.xml:15"));
}
#[test]
fn test_build_embed_text_build_plugin() {
let entity = ParsedEntity::new(
"org.apache.maven.plugins:maven-compiler-plugin:3.11.0",
EntityKind::BuildPlugin,
"org.apache.maven.plugins:maven-compiler-plugin:3.11.0",
None,
Some("Maven plugin: org.apache.maven.plugins:maven-compiler-plugin:3.11.0".to_string()),
"xml",
"pom.xml",
30,
35,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[build_plugin]"));
assert!(embed_text.contains("maven-compiler-plugin"));
assert!(embed_text.contains("Maven plugin:"));
assert!(embed_text.contains("File: pom.xml:30"));
}
#[test]
fn test_build_embed_text_build_task() {
let entity = ParsedEntity::new(
"buildDocs",
EntityKind::BuildTask,
"buildDocs",
None,
Some("task buildDocs(type: Copy) {".to_string()),
"groovy",
"build.gradle",
25,
25,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[build_task] buildDocs"));
assert!(embed_text.contains("task buildDocs(type: Copy) {"));
assert!(embed_text.contains("File: build.gradle:25"));
}
#[test]
fn test_build_embed_text_pipeline_stage() {
let entity = ParsedEntity::new(
"stage: Build",
EntityKind::PipelineStage,
"stage: Build",
None,
Some("stage('Build') {".to_string()),
"groovy",
"Jenkinsfile",
10,
10,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[pipeline_stage] stage: Build"));
assert!(embed_text.contains("File: Jenkinsfile:10"));
}
#[test]
fn test_build_embed_text_pipeline_step() {
let entity = ParsedEntity::new(
"sh: mvn compile",
EntityKind::PipelineStep,
"sh: mvn compile",
None,
Some("sh 'mvn compile'".to_string()),
"groovy",
"Jenkinsfile",
12,
12,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[pipeline_step] sh: mvn compile"));
assert!(embed_text.contains("File: Jenkinsfile:12"));
}
#[test]
fn test_build_embed_text_groovy_class() {
let entity = ParsedEntity::new(
"MyGroovyClass",
EntityKind::GroovyClass,
"com.example.MyGroovyClass",
None,
Some("A Groovy class".to_string()),
"groovy",
"src/MyGroovyClass.groovy",
1,
10,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[groovy_class] MyGroovyClass"));
assert!(embed_text.contains("A Groovy class"));
}
#[test]
fn test_build_embed_text_groovy_interface() {
let entity = ParsedEntity::new(
"MyGroovyInterface",
EntityKind::GroovyInterface,
"com.example.MyGroovyInterface",
None,
None,
"groovy",
"src/MyGroovyInterface.groovy",
1,
5,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[groovy_interface] MyGroovyInterface"));
}
#[test]
fn test_build_embed_text_groovy_trait() {
let entity = ParsedEntity::new(
"MyGroovyTrait",
EntityKind::GroovyTrait,
"com.example.MyGroovyTrait",
None,
None,
"groovy",
"src/MyGroovyTrait.groovy",
1,
8,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[groovy_trait] MyGroovyTrait"));
}
#[test]
fn test_build_embed_text_groovy_method() {
let mut entity = ParsedEntity::new(
"save",
EntityKind::GroovyMethod,
"UserService.save",
Some("def save(User user)".to_string()),
Some("Saves the user".to_string()),
"groovy",
"UserService.groovy",
42,
46,
Some("UserService".to_string()),
"test-repo",
);
entity.decorators = vec!["@Transactional".to_string()];
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[groovy_method] save"));
assert!(embed_text.contains("Signature: def save(User user)"));
assert!(embed_text.contains("Saves the user"));
assert!(embed_text.contains("Decorators: @Transactional"));
}
#[test]
fn test_embed_text_groovy_method_includes_docstring() {
let entity = ParsedEntity::new(
"init",
EntityKind::GroovyMethod,
"nextflow.plugin.extension.PluginExtensionPoint.init",
Some("abstract protected void init(Session session)".to_string()),
Some(
"Channel factory initialization. This method is invoked one and only once"
.to_string(),
),
"groovy",
"PluginExtensionPoint.groovy",
12,
12,
Some("PluginExtensionPoint".to_string()),
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[groovy_method] init"));
assert!(embed_text.contains("Channel factory initialization"));
}
#[test]
fn test_build_embed_text_groovy_property() {
let entity = ParsedEntity::new(
"config",
EntityKind::GroovyProperty,
"com.example.App.config",
None,
None,
"groovy",
"App.groovy",
3,
3,
None,
"test-repo",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("[groovy_property] config"));
}
#[test]
fn embed_text_includes_fqn() {
let entity = ParsedEntity::new(
"login",
EntityKind::RustFunction,
"jobwatch::api::auth::login",
None,
None,
"rust",
"src/api/auth.rs",
136,
160,
None,
"job-watch",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("jobwatch::api::auth::login"));
}
#[test]
fn embed_text_includes_tokenized_identifier() {
let entity = ParsedEntity::new(
"useChangePassword",
EntityKind::Function,
"useChangePassword",
None,
None,
"typescript",
"src/api/authQueries.ts",
5,
12,
None,
"ui",
);
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("Identifier: use change password"));
let snake = ParsedEntity::new(
"verify_credentials_or_fail",
EntityKind::RustFunction,
"verify_credentials_or_fail",
None,
None,
"rust",
"src/api/auth.rs",
190,
200,
None,
"job-watch",
);
let embed_text = build_embed_text(&snake);
assert!(embed_text.contains("Identifier: verify credentials or fail"));
}
#[test]
fn embed_text_includes_outgoing_call_names() {
let mut entity = ParsedEntity::new(
"login",
EntityKind::RustFunction,
"login",
None,
None,
"rust",
"src/api/auth.rs",
136,
160,
None,
"job-watch",
);
entity.reference_intents.push(ReferenceIntent::Call {
method: "normalize_email".to_string(),
receiver: None,
line: 1,
arg_count: None,
});
entity.reference_intents.push(ReferenceIntent::Call {
method: "new".to_string(),
receiver: None,
line: 2,
arg_count: None,
});
entity.reference_intents.push(ReferenceIntent::Call {
method: "useChangePassword".to_string(),
receiver: None,
line: 3,
arg_count: None,
});
let embed_text = build_embed_text(&entity);
assert!(embed_text.contains("Calls: normalize email, new, use change password"));
}
#[test]
fn embed_text_is_deterministic_and_bounded() {
let build = |calls: usize| {
let mut entity = ParsedEntity::new(
"hub",
EntityKind::RustFunction,
"hub",
None,
None,
"rust",
"src/hub.rs",
1,
2,
None,
"r",
);
for i in 0..calls {
entity.reference_intents.push(ReferenceIntent::Call {
method: if i == 0 {
"hub".to_string() } else {
format!("callee_{i:03}")
},
receiver: None,
line: i + 1,
arg_count: None,
});
}
prepare_entities(std::slice::from_mut(&mut entity));
(entity.embed_text.clone(), entity)
};
let (first, _) = build(0);
let (second, _) = build(0);
assert_eq!(first, second, "same entity must embed identically");
let (many, _) = build(60);
let counted = many
.lines()
.find(|l| l.starts_with("Calls:"))
.expect("Calls section present");
let names = counted.trim_start_matches("Calls: ").split(", ").count();
assert_eq!(names, 20, "Calls section capped at 20 names");
let (with_self, _) = build(3);
assert!(!with_self.contains("Calls: hub"));
}
}