MATCH (r:Repository {name: 'forwardlane-backend'})-[:HAS_MODEL]->(m:DataModel)
RETURN m.name, m.file_path, m.field_count, m.has_meta
ORDER BY m.name

MATCH (r:Repository)
RETURN r.name, r.score, r.tier, r.language, r.commit_count
ORDER BY r.score DESC
LIMIT 10

MATCH (r:Repository)-[:HAS_ENDPOINT]->(e:APIEndpoint)
WITH r, count(e) AS endpoint_count
ORDER BY endpoint_count DESC
RETURN r.name, r.tier, endpoint_count
LIMIT 10

MATCH (r:Repository)
WHERE NOT (r)-[:HAS_TEST]->(:TestCase)
  AND r.language IN ['Python', 'TypeScript', 'JavaScript']
RETURN r.name, r.tier, r.commit_count
ORDER BY r.commit_count DESC

MATCH (r:Repository)
WHERE NOT (r)-[:IMPORTS]->(:Repository)
  AND NOT (:Repository)-[:IMPORTS]->(r)
RETURN r.name, r.tier, r.language
ORDER BY r.tier, r.name

MATCH (f:Function)
WHERE f.complexity > 10
RETURN f.name, f.repo, f.file_path, f.complexity
ORDER BY f.complexity DESC
LIMIT 50

MATCH (f:Function)
WHERE toLower(f.name) CONTAINS 'auth'
   OR toLower(f.name) CONTAINS 'login'
   OR toLower(f.name) CONTAINS 'token'
   OR any(d IN f.decorators WHERE d CONTAINS 'login_required' OR d CONTAINS 'permission')
RETURN f.name, f.repo, f.file_path, f.decorators
ORDER BY f.repo, f.name

MATCH (caller:Function)-[:CALLS]->(callee:Function)
WITH callee, count(caller) AS call_count
WHERE call_count >= 3
ORDER BY call_count DESC
RETURN callee.name, callee.repo, callee.file_path, call_count
LIMIT 20

MATCH (caller:Function)-[:CALLS]->(callee:Function)
WHERE caller.repo <> callee.repo
RETURN caller.repo AS from_repo,
       caller.name AS caller_fn,
       callee.repo AS to_repo,
       callee.name AS callee_fn
ORDER BY from_repo, to_repo
LIMIT 30

MATCH (c:Contributor)-[:COMMITTED_TO]->(r:Repository)
WITH c, collect(r.name) AS repos, count(r) AS repo_count
WHERE repo_count >= 5
RETURN c.name, c.total_commits, repo_count, repos
ORDER BY repo_count DESC

MATCH (c:Contributor)
RETURN c.name, c.email, c.total_commits, c.repos_count, c.last_seen
ORDER BY c.total_commits DESC
LIMIT 20

MATCH (c:Contributor)
WHERE c.last_seen < datetime('2023-01-01')
RETURN c.name, c.email, c.total_commits, c.last_seen
ORDER BY c.last_seen DESC

MATCH (r:Repository)
WITH r
MATCH (c:Contributor)-[:COMMITTED_TO]->(r)
WITH r, count(c) AS contributor_count
WHERE contributor_count = 1
RETURN r.name, r.tier, contributor_count
ORDER BY r.tier, r.name

MATCH (s:SecurityPattern)
WHERE s.severity = 'high'
RETURN s.type, s.repo, s.file_path, s.description
ORDER BY s.repo, s.type

MATCH (r:Repository)-[:HAS_SECURITY_ISSUE]->(s:SecurityPattern)
WITH r, count(s) AS issue_count, collect(s.severity) AS severities
ORDER BY issue_count DESC
RETURN r.name, r.tier, issue_count, severities
LIMIT 10

MATCH (s:SecurityPattern)
WHERE s.type = 'hardcoded_secret'
RETURN s.repo, s.file_path, s.severity, s.description
ORDER BY s.severity DESC, s.repo

MATCH (m:DataModel)-[:HAS_FIELD]->(f:ModelField)
WHERE f.field_type = 'ForeignKey'
RETURN m.name, m.repo, f.name, f.fk_target
ORDER BY m.repo, m.name

MATCH (m:DataModel)
RETURN m.name, m.repo, m.field_count
ORDER BY m.field_count DESC
LIMIT 20

MATCH (m:DataModel)
WHERE toLower(m.name) CONTAINS 'payment'
   OR toLower(m.name) CONTAINS 'invoice'
   OR toLower(m.name) CONTAINS 'billing'
   OR toLower(m.name) CONTAINS 'subscription'
RETURN m.name, m.repo, m.file_path, m.field_count
ORDER BY m.repo

MATCH (t:TestCase)-[:TESTS]->(c:Class)
WHERE c.name = 'PortfolioSerializer'
RETURN t.name, t.repo, t.file_path, t.test_type

MATCH (r1:Repository), (r2:Repository)
WHERE r1.name < r2.name
  AND r1.language = r2.language
  AND r1.tier = r2.tier
  AND abs(r1.commit_count - r2.commit_count) < 500
RETURN r1.name, r2.name, r1.language, r1.tier, r1.commit_count, r2.commit_count
LIMIT 20

MATCH (r1:Repository)<-[:COMMITTED_TO]-(c:Contributor)-[:COMMITTED_TO]->(r2:Repository)
WHERE r1.name < r2.name
WITH r1, r2, collect(c.name) AS shared_contributors, count(c) AS shared_count
WHERE shared_count >= 3
RETURN r1.name, r2.name, shared_count, shared_contributors
ORDER BY shared_count DESC
LIMIT 15

MATCH path = (child:Class)-[:INHERITS_FROM*2..]->(ancestor:Class)
RETURN child.name, child.repo,
       [n IN nodes(path) | n.name] AS chain,
       length(path) AS depth
ORDER BY depth DESC
LIMIT 10

MATCH (r:Repository)-[:HAS_CONFIG]->(c1:ConfigFile {config_type: 'docker'}),
      (r)-[:HAS_CONFIG]->(c2:ConfigFile {config_type: 'ci'})
RETURN r.name, r.tier, c1.path AS dockerfile, c2.path AS ci_config
ORDER BY r.tier, r.name

MATCH (r:Repository)
WITH r.tier AS tier, r.language AS language, count(r) AS repo_count
ORDER BY tier, repo_count DESC
RETURN tier, language, repo_count

MATCH (r:Repository)-[:HAS_FUNCTION]->(f:Function)
WHERE f.complexity IS NOT NULL
WITH r, avg(f.complexity) AS avg_complexity, max(f.complexity) AS max_complexity, count(f) AS fn_count
ORDER BY avg_complexity DESC
RETURN r.name, r.tier, round(avg_complexity * 10) / 10 AS avg_complexity, max_complexity, fn_count
LIMIT 15

MATCH (r:Repository)
WHERE r.function_count > 0
WITH r,
     toFloat(r.test_count) / r.function_count AS test_ratio
ORDER BY test_ratio DESC
RETURN r.name, r.tier, r.test_count, r.function_count,
       round(test_ratio * 100) / 100 AS tests_per_function
LIMIT 20