feat: enhance cwd resolution and model duplicates

Be permissive when access to a field when has a duplicated
model from another app, to handle those cases we need to
track each app separately increasing the complexity. For
now is good enough to be permissive when two models has
the same name but in different apps or modules.

Avoid considering `Base` as a django model base model, that
is wrong because `Base` is a common name for a bunch of
applications and can override the original django model
incorrectly.

Aditionally prioritize cwd using `manage.py` as a marker.

Author: richardhapb

.github/workflows/pypi-release.yml

@@ -137,12 +137,6 @@ jobs:
     runs-on: ubuntu-latest
     steps:
       - uses: actions/checkout@v6
-      - name: Replace symlinks with actual files
-        run: |
-          cd crates/django-check
-          rm -f LICENSE README.md
-          cp ../../LICENSE LICENSE
-          cp ../../README.md README.md
       - name: Build sdist
         uses: PyO3/maturin-action@v1
         with:

Cargo.lock

@@ -1,6 +1,6 @@
 [package]
 name = "django-check"
-version = "0.1.7"
+version = "0.1.8"
 rust-version = { workspace = true }
 license = { workspace = true }
 authors = { workspace = true }

crates/django-check/Cargo.toml

@@ -4,7 +4,7 @@ build-backend = "maturin"
 
 [project]
 name = "djch"
-version = "0.1.7"
+version = "0.1.8"
 description = "Static N+1 query detector for Django ORM – fast Rust-powered checker"
 # For PyPI long description (shows formatted on project page)
 readme = {file = "README.md", content-type = "text/markdown"}

crates/django-check/pyproject.toml

@@ -1,5 +1,5 @@
 mod cli;
-use std::path::Path;
+use std::path::{Path, PathBuf};
 
 use django_check_semantic::Parser;
 use django_check_server::serve;
@@ -12,29 +12,97 @@ use tracing_subscriber::{EnvFilter, filter::LevelFilter};
 #[tokio::main]
 async fn main() -> Result<(), Box<dyn std::error::Error>> {
     let cwd = current_dir().expect("should get the cwd");
+    let root = resolve_project_root(&cwd);
     let parser = Parser::new();
 
-    let model_graph = parser.extract_model_graph(&cwd)?;
-    let functions = parser.extract_functions(&cwd)?;
+    let model_graph = parser.extract_model_graph(&root)?;
+    let functions = parser.extract_functions(&root)?;
 
     let cli = Cli::parse();
 
     match cli.cmd {
         Cmd::Check => {
             initialize_logger(false);
-            if let Err(e) = parser.analyze_directory(&cwd, &model_graph, &functions) {
+            if let Err(e) = parser.analyze_directory(&root, &model_graph, &functions) {
                 eprintln!("Error: {}", e);
             }
         }
         Cmd::Server => {
             initialize_logger(true);
-            serve(&cwd, model_graph, functions).await;
+            serve(&root, model_graph, functions).await;
         }
     }
 
     Ok(())
 }
 
+fn resolve_project_root(cwd: &Path) -> PathBuf {
+    // Prefer the current directory when it already looks like a Django project.
+    if cwd.join("manage.py").is_file() {
+        return cwd.to_path_buf();
+    }
+
+    // If we're one level above the app folder, pick that folder automatically.
+    let nested_candidates = std::fs::read_dir(cwd)
+        .ok()
+        .into_iter()
+        .flat_map(|entries| entries.filter_map(Result::ok))
+        .map(|entry| entry.path())
+        .filter(|path| path.is_dir() && path.join("manage.py").is_file())
+        .collect::<Vec<_>>();
+
+    if nested_candidates.len() == 1 {
+        return nested_candidates[0].clone();
+    }
+
+    cwd.to_path_buf()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::resolve_project_root;
+    use std::path::Path;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn unique_suffix() -> u128 {
+        SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("clock should be after unix epoch")
+            .as_nanos()
+    }
+
+    #[test]
+    fn prefers_current_directory_when_manage_py_exists() {
+        let base = std::env::temp_dir().join(format!(
+            "djch-root-current-{}-{}",
+            std::process::id(),
+            unique_suffix()
+        ));
+        std::fs::create_dir_all(&base).expect("create temp dir");
+        std::fs::write(base.join("manage.py"), "").expect("create manage.py");
+
+        assert_eq!(resolve_project_root(&base), base);
+
+        std::fs::remove_dir_all(&base).expect("cleanup temp dir");
+    }
+
+    #[test]
+    fn picks_single_nested_django_directory() {
+        let base = std::env::temp_dir().join(format!(
+            "djch-root-nested-{}-{}",
+            std::process::id(),
+            unique_suffix()
+        ));
+        let app = base.join("app");
+        std::fs::create_dir_all(&app).expect("create app dir");
+        std::fs::write(app.join("manage.py"), "").expect("create nested manage.py");
+
+        assert_eq!(resolve_project_root(Path::new(&base)), app);
+
+        std::fs::remove_dir_all(&base).expect("cleanup temp dir");
+    }
+}
+
 fn initialize_logger(with_file: bool) {
     let env_filter = EnvFilter::from_default_env();
 

crates/django-check/src/main.rs

@@ -36,16 +36,12 @@ impl Parser {
     fn analyze_n_plus_one_file(
         &self,
         file: &Path,
+        display_file: &str,
         model_graph: &ModelGraph,
         functions: &[QueryFunction],
     ) -> Result<Vec<NPlusOneDiagnostic>, SourceParseError> {
         let source = fs::read_to_string(file)?;
-        self.analyze_source(
-            &source,
-            file.to_str().expect("conver to str"),
-            model_graph,
-            functions,
-        )
+        self.analyze_source(&source, display_file, model_graph, functions)
     }
 
     /// Run N+1 detection on a file or a directory, this function figure out
@@ -61,11 +57,10 @@ impl Parser {
 
         if path.is_dir() {
             for entry in Self::python_files(path) {
+                let display_path = Self::relative_path(path, entry.path());
                 let diagnostics = match self.analyze_n_plus_one_file(
-                    entry
-                        .path()
-                        .strip_prefix(path)
-                        .expect("path derived from prefix"),
+                    entry.path(),
+                    &display_path,
                     model_graph,
                     functions,
                 ) {
@@ -78,7 +73,9 @@ impl Parser {
                 all_diagnostics.extend(diagnostics);
             }
         } else if path.is_file() {
-            all_diagnostics = self.analyze_n_plus_one_file(path, model_graph, functions)?;
+            let display_path = path.to_string_lossy().to_string();
+            all_diagnostics =
+                self.analyze_n_plus_one_file(path, &display_path, model_graph, functions)?;
         }
 
         Ok(all_diagnostics)
@@ -167,7 +164,8 @@ impl Parser {
         model_graph: &ModelGraph,
         functions: &[QueryFunction],
     ) -> Result<Vec<NPlusOneDiagnostic>, SourceParseError> {
-        self.analyze_n_plus_one_file(file, model_graph, functions)
+        let display_path = file.to_string_lossy().to_string();
+        self.analyze_n_plus_one_file(file, &display_path, model_graph, functions)
     }
 
     /// Run all analyses in a source code and return diagnostics

crates/django-check_semantic/src/parser.rs

@@ -72,8 +72,9 @@ impl<'a> ModelGraphPass<'a> {
                 // Direct Model import or custom base class
                 Expr::Name(name) => {
                     let n = name.id.as_str();
-                    // Common patterns: Model, BaseModel, AbstractModel, etc.
-                    if n == "Model" || n.ends_with("Model") || n.ends_with("Base") {
+                    // Common Django patterns: Model, BaseModel, AbstractModel, etc.
+                    // Avoid generic `Base` classes (e.g. SQLAlchemy declarative base).
+                    if n == "Model" || n.ends_with("Model") {
                         return true;
                     }
                 }
@@ -226,16 +227,30 @@ fn extract_related_name(call: &ruff_python_ast::ExprCall) -> Option<String> {
 
 /// Analyze an Stmt and capture the relation if it exists
 fn extract_relation_from_stmt(stmt: &Stmt, model_name: &str) -> Option<Relation> {
-    let Stmt::Assign(assign) = stmt else {
-        return None;
-    };
-
-    let Some(Expr::Name(target)) = assign.targets.first() else {
-        return None;
-    };
-    let field_name = target.id.to_string();
+    match stmt {
+        Stmt::Assign(assign) => {
+            let Some(Expr::Name(target)) = assign.targets.first() else {
+                return None;
+            };
+            extract_relation_from_value(&target.id, assign.value.as_ref(), model_name)
+        }
+        Stmt::AnnAssign(assign) => {
+            let Expr::Name(target) = assign.target.as_ref() else {
+                return None;
+            };
+            let value = assign.value.as_ref()?;
+            extract_relation_from_value(&target.id, value, model_name)
+        }
+        _ => None,
+    }
+}
 
-    let Expr::Call(call) = assign.value.as_ref() else {
+fn extract_relation_from_value(
+    field_name: &str,
+    value: &Expr,
+    model_name: &str,
+) -> Option<Relation> {
+    let Expr::Call(call) = value else {
         return None;
     };
 
@@ -245,7 +260,7 @@ fn extract_relation_from_stmt(stmt: &Stmt, model_name: &str) -> Option<Relation>
 
     Some(Relation::new(
         model_name,
-        field_name,
+        field_name.to_string(),
         target_model,
         relation_type,
         related_name,
@@ -382,6 +397,21 @@ class Article(models.Model):
         assert_eq!(article.relations[1].relation_type, RelationType::ManyToMany);
     }
 
+    #[test]
+    fn extract_annotated_relation_fields() {
+        let source = r#"
+class Profile(models.Model):
+    user: User = models.ForeignKey(User, on_delete=models.CASCADE)
+    "#;
+        let graph = run_pass(source);
+        let profile = graph.get("Profile").expect("Profile should exist");
+
+        assert_eq!(profile.relations.len(), 1);
+        assert_eq!(profile.relations[0].field_name, "user");
+        assert_eq!(profile.relations[0].target_model, "User");
+        assert_eq!(profile.relations[0].relation_type, RelationType::ForeignKey);
+    }
+
     #[test]
     fn dependents_query() {
         let source = r#"
@@ -513,4 +543,18 @@ class CreatedOrder(Order):
                     && r.related_name("CreatedOrder") == "createdorders")
         );
     }
+
+    #[test]
+    fn doesnt_extract_sqlalchemy_base_models() {
+        let source = r#"
+from sqlalchemy.ext.declarative import declarative_base
+
+Base = declarative_base()
+
+class User(Base):
+    pass
+"#;
+        let graph = run_pass(source);
+        assert_eq!(graph.model_count(), 0);
+    }
 }