diff --git a/.dockerignore b/.dockerignore
new file mode 100644
index 000000000..04be9f36b
--- /dev/null
+++ b/.dockerignore
@@ -0,0 +1,23 @@
+.git
+__pycache__
+*.py[oc]
+.venv
+.env
+.envrc
+.ruff_cache
+.mypy_cache
+.pytest_cache
+.claude
+.coverage
+.DS_Store
+build
+dist
+wheels
+*.egg-info
+docs
+site
+.github
+.qdrant_code_embeddings
+CLAUDE.md
+AGENTS.md
+PROJECT.md
diff --git a/.env.example b/.env.example
index dc518b501..9e449e031 100644
--- a/.env.example
+++ b/.env.example
@@ -60,6 +60,17 @@
# CYPHER_MODEL=gemini-2.5-flash
# CYPHER_API_KEY=your-google-api-key
+# Example 6: LiteLLM with custom provider
+# ORCHESTRATOR_PROVIDER=litellm_proxy
+# ORCHESTRATOR_MODEL=gpt-oss:120b
+# ORCHESTRATOR_ENDPOINT=http://litellm:4000/v1
+# ORCHESTRATOR_API_KEY=sk-your-litellm-key
+
+# CYPHER_PROVIDER=litellm_proxy
+# CYPHER_MODEL=openrouter/gpt-oss:120b
+# CYPHER_ENDPOINT=http://litellm:4000/v1
+# CYPHER_API_KEY=sk-your-litellm-key
+
# Thinking budget for reasoning models (optional)
# ORCHESTRATOR_THINKING_BUDGET=10000
# CYPHER_THINKING_BUDGET=5000
@@ -68,9 +79,20 @@
MEMGRAPH_HOST=localhost
MEMGRAPH_PORT=7687
MEMGRAPH_HTTP_PORT=7444
+# Memgraph authentication credentials
+# Leave MEMGRAPH_USERNAME empty (or omit it) if your Memgraph instance doesn't require authentication
+# If authentication is enabled, provide both username and password
+# Common defaults: username=neo4j, password=password (or your custom credentials)
+MEMGRAPH_USERNAME=
+MEMGRAPH_PASSWORD=
LAB_PORT=3000
MEMGRAPH_BATCH_SIZE=1000
+# Qdrant settings
+# Leave QDRANT_URL unset to use local file mode (only suitable below ~20k embeddings)
+# For larger codebases, run the bundled docker-compose service and point at it:
+# QDRANT_URL=http://localhost:6333
+
# Repository settings
TARGET_REPO_PATH=.
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 000000000..49ff9c712
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1 @@
+* @vitali87
diff --git a/.github/FUNDING.yml b/.github/FUNDING.yml
index d5f29c336..163b5ae21 100644
--- a/.github/FUNDING.yml
+++ b/.github/FUNDING.yml
@@ -3,5 +3,4 @@
github: vitali87
buy_me_a_coffee: vitali87
-# Uncomment and add username when you set up Patreon:
-# patreon: YOUR_USERNAME
+patreon: vitali87
diff --git a/.github/ISSUE_TEMPLATE/config.yml b/.github/ISSUE_TEMPLATE/config.yml
index 4b6f8f59b..2c5488f8e 100644
--- a/.github/ISSUE_TEMPLATE/config.yml
+++ b/.github/ISSUE_TEMPLATE/config.yml
@@ -1,11 +1,8 @@
-blank_issues_enabled: false
+blank_issues_enabled: true
contact_links:
- - name: 💬 Discussions
- url: https://github.com/vitali87/code-graph-rag/discussions
- about: Ask questions and discuss ideas with the community
- name: 📚 Documentation
- url: https://github.com/vitali87/code-graph-rag#readme
+ url: https://codeberg.org/vitali87/code-graph-rag
about: Read the documentation and setup guides
- name: 🎓 MCP Server Setup
- url: https://github.com/vitali87/code-graph-rag/blob/main/docs/claude-code-setup.md
+ url: https://codeberg.org/vitali87/code-graph-rag/src/branch/main/docs/claude-code-setup.md
about: Setup Code-Graph-RAG as an MCP server with Claude Code
diff --git a/.github/ISSUE_TEMPLATE/documentation.yml b/.github/ISSUE_TEMPLATE/documentation.yml
index 0f84c3651..f3dbfcce1 100644
--- a/.github/ISSUE_TEMPLATE/documentation.yml
+++ b/.github/ISSUE_TEMPLATE/documentation.yml
@@ -31,7 +31,7 @@ body:
attributes:
label: URL (if applicable)
description: Link to the documentation page
- placeholder: "https://github.com/vitali87/code-graph-rag/blob/main/..."
+ placeholder: "https://codeberg.org/vitali87/code-graph-rag/src/branch/main/..."
- type: textarea
id: current-state
diff --git a/.github/ISSUE_TEMPLATE/question.yml b/.github/ISSUE_TEMPLATE/question.yml
index 47d83bcd9..40150201c 100644
--- a/.github/ISSUE_TEMPLATE/question.yml
+++ b/.github/ISSUE_TEMPLATE/question.yml
@@ -6,7 +6,7 @@ body:
- type: markdown
attributes:
value: |
- Thank you for your question! For general discussions or open-ended questions, consider using [GitHub Discussions](https://github.com/vitali87/code-graph-rag/discussions).
+ Thank you for your question! Please keep questions concrete; for broader topics, prefer opening an [issue](https://codeberg.org/vitali87/code-graph-rag/issues) with the `question` label.
- type: textarea
id: question
diff --git a/.github/dependabot.yml b/.github/dependabot.yml
new file mode 100644
index 000000000..a075b29ee
--- /dev/null
+++ b/.github/dependabot.yml
@@ -0,0 +1,16 @@
+version: 2
+updates:
+ - package-ecosystem: "github-actions"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+
+ - package-ecosystem: "docker"
+ directory: "/"
+ schedule:
+ interval: "weekly"
+
+ - package-ecosystem: "pip"
+ directory: "/"
+ schedule:
+ interval: "weekly"
diff --git a/.github/pull_request_template.md b/.github/pull_request_template.md
new file mode 100644
index 000000000..8dc054f6c
--- /dev/null
+++ b/.github/pull_request_template.md
@@ -0,0 +1,38 @@
+## Summary
+
+
+
+-
+
+## Type of Change
+
+
+
+- [ ] Bug fix
+- [ ] New feature
+- [ ] Performance improvement
+- [ ] Refactoring (no functional changes)
+- [ ] Documentation
+- [ ] CI/CD or tooling
+- [ ] Dependencies
+
+## Related Issues
+
+
+
+## Test Plan
+
+
+
+- [ ] Unit tests pass (`make test-parallel` or `uv run pytest -n auto -m "not integration"`)
+- [ ] New tests added
+- [ ] Integration tests pass (`make test-integration`, requires Docker)
+- [ ] Manual testing (describe below)
+
+## Checklist
+
+- [ ] PR title follows [Conventional Commits](https://www.conventionalcommits.org/) format
+- [ ] All pre-commit checks pass (`make pre-commit`)
+- [ ] No hardcoded strings in non-config/non-constants files
+- [ ] No `# type: ignore`, `cast()`, `Any`, or `object` type hints
+- [ ] No new comments or docstrings (code should be self-documenting)
diff --git a/.github/workflows/build-binaries.yml b/.github/workflows/build-binaries.yml
index c548d82ea..315cfa45a 100644
--- a/.github/workflows/build-binaries.yml
+++ b/.github/workflows/build-binaries.yml
@@ -8,10 +8,14 @@ on:
release:
types: [created]
+permissions: read-all
+
jobs:
build:
name: Build ${{ matrix.platform }}-${{ matrix.arch }}
runs-on: ${{ matrix.os }}
+ permissions:
+ contents: write
timeout-minutes: 30
strategy:
fail-fast: false
@@ -32,18 +36,18 @@ jobs:
steps:
- name: Checkout code
- uses: actions/checkout@v4
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
fetch-depth: 0
submodules: recursive
- name: Set up Python
- uses: actions/setup-python@v5
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
with:
python-version: "3.12"
- name: Install uv
- uses: astral-sh/setup-uv@v4
+ uses: astral-sh/setup-uv@e4db8464a088ece1b920f60402e813ea4de65b8f # v4
with:
enable-cache: true
cache-dependency-glob: "uv.lock"
@@ -66,7 +70,7 @@ jobs:
fi
- name: Upload binary artifact
- uses: actions/upload-artifact@v4
+ uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
with:
name: code-graph-rag-${{ matrix.platform }}-${{ matrix.arch }}
path: dist/code-graph-rag-*
@@ -75,7 +79,39 @@ jobs:
- name: Upload to release
if: startsWith(github.ref, 'refs/tags/v')
- uses: softprops/action-gh-release@v2
+ uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b # v2
with:
files: dist/code-graph-rag-*
fail_on_unmatched_files: true
+
+ sign-release:
+ name: Sign Release Artifacts
+ if: startsWith(github.ref, 'refs/tags/v')
+ needs: build
+ runs-on: ubuntu-latest
+ permissions:
+ contents: write
+ id-token: write
+ steps:
+ - name: Install cosign
+ uses: sigstore/cosign-installer@ba7bc0a3fef59531c69a25acd34668d6d3fe6f22 # v4.1.0
+
+ - name: Download all artifacts
+ uses: actions/download-artifact@d3f86a106a0bac45b974a628896c90dbdf5c8093 # v4
+ with:
+ path: artifacts
+ merge-multiple: true
+
+ - name: Sign artifacts
+ shell: bash
+ run: |
+ for f in artifacts/*; do
+ [ -f "$f" ] || continue
+ cosign sign-blob --yes --bundle "${f}.sigstore.json" "$f"
+ done
+
+ - name: Upload signatures to release
+ uses: softprops/action-gh-release@a06a81a03ee405af7f2048a818ed3f03bbf83c7b # v2
+ with:
+ files: artifacts/*.sigstore.json
+ fail_on_unmatched_files: false
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 43b0cc8db..a7742b439 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -7,6 +7,8 @@ on:
branches: [main, master, develop]
workflow_dispatch:
+permissions: read-all
+
concurrency:
group: ${{ github.workflow }}-${{ github.ref }}
cancel-in-progress: true
@@ -19,16 +21,16 @@ jobs:
steps:
- name: Checkout code
- uses: actions/checkout@v4
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
- name: Install uv
- uses: astral-sh/setup-uv@v4
+ uses: astral-sh/setup-uv@e4db8464a088ece1b920f60402e813ea4de65b8f # v4
with:
enable-cache: true
cache-dependency-glob: "uv.lock"
- name: Set up Python
- uses: actions/setup-python@v5
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
with:
python-version: "3.12"
@@ -51,16 +53,16 @@ jobs:
steps:
- name: Checkout code
- uses: actions/checkout@v4
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
- name: Install uv
- uses: astral-sh/setup-uv@v4
+ uses: astral-sh/setup-uv@e4db8464a088ece1b920f60402e813ea4de65b8f # v4
with:
enable-cache: true
cache-dependency-glob: "uv.lock"
- name: Set up Python
- uses: actions/setup-python@v5
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
with:
python-version: "3.12"
@@ -75,7 +77,7 @@ jobs:
test-unit:
name: Unit Tests (${{ matrix.os }})
runs-on: ${{ matrix.os }}
- timeout-minutes: 15
+ timeout-minutes: 20
strategy:
fail-fast: false
matrix:
@@ -83,19 +85,19 @@ jobs:
steps:
- name: Checkout code
- uses: actions/checkout@v4
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
submodules: recursive
fetch-depth: 0
- name: Install uv
- uses: astral-sh/setup-uv@v4
+ uses: astral-sh/setup-uv@e4db8464a088ece1b920f60402e813ea4de65b8f # v4
with:
enable-cache: true
cache-dependency-glob: "uv.lock"
- name: Set up Python
- uses: actions/setup-python@v5
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
with:
python-version: "3.12"
@@ -103,13 +105,19 @@ jobs:
run: |
uv sync --extra treesitter-full --extra test --extra semantic --group dev
- - name: Run unit tests (parallel)
+ - name: Run unit tests (parallel, with coverage)
+ if: matrix.os == 'macos-latest'
run: |
uv run pytest -n auto -m "not integration" --tb=short --cov=codebase_rag --cov-report=xml --cov-report=term
+ - name: Run unit tests (parallel, no coverage)
+ if: matrix.os != 'macos-latest'
+ run: |
+ uv run pytest -n auto -m "not integration" --tb=short
+
- name: Upload coverage to Codecov
- if: always() && secrets.CODECOV_TOKEN != ''
- uses: codecov/codecov-action@v4
+ if: always() && matrix.os == 'macos-latest'
+ uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
with:
files: ./coverage.xml
flags: unit-${{ matrix.os }}
@@ -123,7 +131,7 @@ jobs:
steps:
- name: Checkout code
- uses: actions/checkout@v4
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
submodules: recursive
fetch-depth: 0
@@ -133,7 +141,7 @@ jobs:
docker run -d --name memgraph -p 7687:7687 memgraph/memgraph-platform:latest
echo "Waiting for Memgraph to start..."
for i in {1..30}; do
- if docker exec memgraph echo "SELECT 1;" 2>/dev/null; then
+ if docker exec memgraph mgconsole --no-history -c "RETURN 1;" 2>/dev/null; then
echo "Memgraph is ready!"
break
fi
@@ -142,13 +150,13 @@ jobs:
done
- name: Install uv
- uses: astral-sh/setup-uv@v4
+ uses: astral-sh/setup-uv@e4db8464a088ece1b920f60402e813ea4de65b8f # v4
with:
enable-cache: true
cache-dependency-glob: "uv.lock"
- name: Set up Python
- uses: actions/setup-python@v5
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
with:
python-version: "3.12"
@@ -164,8 +172,8 @@ jobs:
uv run pytest -m "integration" -v --tb=short --cov=codebase_rag --cov-report=xml --cov-report=term
- name: Upload coverage to Codecov
- if: always() && secrets.CODECOV_TOKEN != ''
- uses: codecov/codecov-action@v4
+ if: always()
+ uses: codecov/codecov-action@1af58845a975a7985b0beb0cbe6fbbb71a41dbad # v5.5.3
with:
files: ./coverage.xml
flags: integration-ubuntu-latest
@@ -187,7 +195,7 @@ jobs:
steps:
- name: Check PR title format
- uses: amannn/action-semantic-pull-request@v5
+ uses: amannn/action-semantic-pull-request@48f256284bd46cdaab1048c3721360e808335d50 # v6.1.1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
diff --git a/.github/workflows/claude-code-review.yml b/.github/workflows/claude-code-review.yml
index ecd3732f3..6c0c48ebf 100644
--- a/.github/workflows/claude-code-review.yml
+++ b/.github/workflows/claude-code-review.yml
@@ -10,6 +10,8 @@ on:
- "*.py"
- "pyproject.toml"
+permissions: read-all
+
jobs:
claude-review:
name: AI Code Review
@@ -26,13 +28,13 @@ jobs:
steps:
- name: Checkout repository
- uses: actions/checkout@v4
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
fetch-depth: 1
- name: Run Claude Code Review
id: claude-review
- uses: anthropics/claude-code-action@beta
+ uses: anthropics/claude-code-action@28f83620103c48a57093dcc2837eec89e036bb9f # beta
with:
claude_code_oauth_token: ${{ secrets.CLAUDE_CODE_OAUTH_TOKEN }}
diff --git a/.github/workflows/docker-publish.yml b/.github/workflows/docker-publish.yml
new file mode 100644
index 000000000..853e4df66
--- /dev/null
+++ b/.github/workflows/docker-publish.yml
@@ -0,0 +1,62 @@
+name: Docker Publish
+
+on:
+ push:
+ tags:
+ - 'v*'
+ workflow_dispatch:
+
+env:
+ REGISTRY: ghcr.io
+ IMAGE_NAME: ${{ github.repository }}
+
+permissions: read-all
+
+jobs:
+ build-and-push:
+ runs-on: ubuntu-latest
+ timeout-minutes: 60
+ permissions:
+ contents: read
+ packages: write
+ attestations: write
+ id-token: write
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+ - uses: docker/setup-qemu-action@c7c53464625b32c7a7e944ae62b3e17d2b600130 # v3
+
+ - uses: docker/setup-buildx-action@8d2750c68a42422c14e847fe6c8ac0403b4cbd6f # v3
+
+ - uses: docker/login-action@b45d80f862d83dbcd57f89517bcf500b2ab88fb2 # v4.0.0
+ with:
+ registry: ${{ env.REGISTRY }}
+ username: ${{ github.actor }}
+ password: ${{ secrets.GITHUB_TOKEN }}
+
+ - uses: docker/metadata-action@c299e40c65443455700f0fdfc63efafe5b349051 # v5
+ id: meta
+ with:
+ images: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+ tags: |
+ type=semver,pattern={{version}}
+ type=semver,pattern={{major}}.{{minor}}
+ type=semver,pattern={{major}}
+ type=sha
+
+ - uses: docker/build-push-action@d08e5c354a6adb9ed34480a06d141179aa583294 # v7.0.0
+ id: push
+ with:
+ context: .
+ platforms: linux/amd64,linux/arm64
+ push: true
+ tags: ${{ steps.meta.outputs.tags }}
+ labels: ${{ steps.meta.outputs.labels }}
+ cache-from: type=gha
+ cache-to: type=gha,mode=max
+
+ - uses: actions/attest-build-provenance@96b4a1ef7235a096b17240c259729fdd70c83d45 # v2
+ with:
+ subject-name: ${{ env.REGISTRY }}/${{ env.IMAGE_NAME }}
+ subject-digest: ${{ steps.push.outputs.digest }}
+ push-to-registry: true
diff --git a/.github/workflows/docs.yml b/.github/workflows/docs.yml
new file mode 100644
index 000000000..912c8eb02
--- /dev/null
+++ b/.github/workflows/docs.yml
@@ -0,0 +1,58 @@
+name: Deploy Documentation
+
+on:
+ push:
+ branches:
+ - main
+ paths:
+ - "docs/**"
+ - "mkdocs.yml"
+ # (H) Rebuilds periodically so the GitHub repo widget (version, stars, forks)
+ # stays current; MkDocs Material fetches these stats at build time.
+ schedule:
+ - cron: "0 */6 * * *"
+ workflow_dispatch:
+
+permissions:
+ contents: read
+ pages: write
+ id-token: write
+
+concurrency:
+ group: pages
+ cancel-in-progress: false
+
+jobs:
+ build:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+ - uses: astral-sh/setup-uv@e4db8464a088ece1b920f60402e813ea4de65b8f # v4
+ with:
+ enable-cache: true
+ cache-dependency-glob: "uv.lock"
+
+ - uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: "3.12"
+
+ - name: Install dependencies
+ run: uv sync --group docs
+
+ - name: Build site
+ run: uv run mkdocs build --strict
+
+ - uses: actions/upload-pages-artifact@7b1f4a764d45c48632c6b24a0339c27f5614fb0b # v4.0.0
+ with:
+ path: site
+
+ deploy:
+ needs: build
+ runs-on: ubuntu-latest
+ environment:
+ name: github-pages
+ url: ${{ steps.deployment.outputs.page_url }}
+ steps:
+ - id: deployment
+ uses: actions/deploy-pages@d6db90164ac5ed86f2b6aed7e0febac5b3c0c03e # v4
diff --git a/.github/workflows/label-sync.yml b/.github/workflows/label-sync.yml
index ec787447e..40cc0e2c0 100644
--- a/.github/workflows/label-sync.yml
+++ b/.github/workflows/label-sync.yml
@@ -9,9 +9,10 @@ on:
- ".github/workflows/label-sync.yml"
workflow_dispatch:
schedule:
- # Run weekly on Mondays at 00:00 UTC to ensure labels stay in sync
- cron: "0 0 * * 1"
+permissions: read-all
+
jobs:
sync-labels:
name: Sync Repository Labels
@@ -22,10 +23,10 @@ jobs:
steps:
- name: Checkout repository
- uses: actions/checkout@v4
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
- name: Sync labels
- uses: micnncim/action-label-syncer@v1
+ uses: micnncim/action-label-syncer@3abd5ab72fda571e69fffd97bd4e0033dd5f495c # v1
env:
GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
with:
diff --git a/.github/workflows/osv-scanner.yml b/.github/workflows/osv-scanner.yml
new file mode 100644
index 000000000..5ac2a0a24
--- /dev/null
+++ b/.github/workflows/osv-scanner.yml
@@ -0,0 +1,50 @@
+# This workflow uses actions that are not certified by GitHub.
+# They are provided by a third-party and are governed by
+# separate terms of service, privacy policy, and support
+# documentation.
+
+# A sample workflow which sets up periodic OSV-Scanner scanning for vulnerabilities,
+# in addition to a PR check which fails if new vulnerabilities are introduced.
+#
+# For more examples and options, including how to ignore specific vulnerabilities,
+# see https://google.github.io/osv-scanner/github-action/
+
+name: OSV-Scanner
+
+on:
+ pull_request:
+ branches: [ "main" ]
+ merge_group:
+ branches: [ "main" ]
+ schedule:
+ - cron: '29 2 * * 4'
+ push:
+ branches: [ "main" ]
+
+permissions: read-all
+
+jobs:
+ scan-scheduled:
+ if: ${{ github.event_name == 'push' || github.event_name == 'schedule' }}
+ uses: google/osv-scanner-action/.github/workflows/osv-scanner-reusable.yml@c5996e0193a3df57d695c1b8a1dec2a4c62e8730 # v2.3.3
+ permissions:
+ actions: read
+ security-events: write
+ contents: read
+ with:
+ scan-args: |-
+ -r
+ --skip-git
+ ./
+ scan-pr:
+ if: ${{ github.event_name == 'pull_request' || github.event_name == 'merge_group' }}
+ uses: google/osv-scanner-action/.github/workflows/osv-scanner-reusable-pr.yml@c5996e0193a3df57d695c1b8a1dec2a4c62e8730 # v2.3.3
+ permissions:
+ actions: read
+ security-events: write
+ contents: read
+ with:
+ scan-args: |-
+ -r
+ --skip-git
+ ./
diff --git a/.github/workflows/poor-quality-management.yml b/.github/workflows/poor-quality-management.yml
index df73ada89..657a86dae 100644
--- a/.github/workflows/poor-quality-management.yml
+++ b/.github/workflows/poor-quality-management.yml
@@ -4,9 +4,11 @@ on:
pull_request_target:
types: [labeled]
schedule:
- - cron: "0 9 * * *" # Daily at 9 AM UTC
+ - cron: "0 9 * * *"
workflow_dispatch:
+permissions: read-all
+
jobs:
notify-poor-quality:
name: Notify Poor Quality PR
@@ -19,7 +21,7 @@ jobs:
steps:
- name: Add warning comment
- uses: actions/github-script@v7
+ uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
with:
script: |
const message = `⚠️ **This PR has been marked as poor-quality.**
@@ -73,7 +75,7 @@ jobs:
steps:
- name: Close PRs with poor-quality label older than 7 days
- uses: actions/github-script@v7
+ uses: actions/github-script@ed597411d8f924073f98dfc5c65a23a2325f34cd # v8.0.0
with:
script: |
const LABEL_NAME = 'poor-quality';
diff --git a/.github/workflows/publish.yml b/.github/workflows/publish.yml
new file mode 100644
index 000000000..1201a3a14
--- /dev/null
+++ b/.github/workflows/publish.yml
@@ -0,0 +1,38 @@
+name: Publish to PyPI
+
+on:
+ release:
+ types: [published]
+
+permissions: read-all
+
+jobs:
+ publish:
+ name: Publish to PyPI
+ runs-on: ubuntu-latest
+ timeout-minutes: 10
+ environment: pypi
+ permissions:
+ id-token: write
+ contents: read
+
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+
+ - name: Install uv
+ uses: astral-sh/setup-uv@e4db8464a088ece1b920f60402e813ea4de65b8f # v4
+ with:
+ enable-cache: true
+ cache-dependency-glob: "uv.lock"
+
+ - name: Set up Python
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: "3.12"
+
+ - name: Build package
+ run: uv build
+
+ - name: Publish to PyPI
+ uses: pypa/gh-action-pypi-publish@ed0c53931b1dc9bd32cbe73a98c7f6766f8a527e # release/v1
diff --git a/.github/workflows/scorecard.yml b/.github/workflows/scorecard.yml
new file mode 100644
index 000000000..08b117574
--- /dev/null
+++ b/.github/workflows/scorecard.yml
@@ -0,0 +1,78 @@
+# This workflow uses actions that are not certified by GitHub. They are provided
+# by a third-party and are governed by separate terms of service, privacy
+# policy, and support documentation.
+
+name: Scorecard supply-chain security
+on:
+ # For Branch-Protection check. Only the default branch is supported. See
+ # https://github.com/ossf/scorecard/blob/main/docs/checks.md#branch-protection
+ branch_protection_rule:
+ # To guarantee Maintained check is occasionally updated. See
+ # https://github.com/ossf/scorecard/blob/main/docs/checks.md#maintained
+ schedule:
+ - cron: '32 23 * * 2'
+ push:
+ branches: [ "main" ]
+
+# Declare default permissions as read only.
+permissions: read-all
+
+jobs:
+ analysis:
+ name: Scorecard analysis
+ runs-on: ubuntu-latest
+ # `publish_results: true` only works when run from the default branch. conditional can be removed if disabled.
+ if: github.event.repository.default_branch == github.ref_name || github.event_name == 'pull_request'
+ permissions:
+ # Needed to upload the results to code-scanning dashboard.
+ security-events: write
+ # Needed to publish results and get a badge (see publish_results below).
+ id-token: write
+ # Uncomment the permissions below if installing in a private repository.
+ # contents: read
+ # actions: read
+
+ steps:
+ - name: "Checkout code"
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ persist-credentials: false
+
+ - name: "Run analysis"
+ uses: ossf/scorecard-action@4eaacf0543bb3f2c246792bd56e8cdeffafb205a # v2.4.3
+ with:
+ results_file: results.sarif
+ results_format: sarif
+ # (Optional) "write" PAT token. Uncomment the `repo_token` line below if:
+ # - you want to enable the Branch-Protection check on a *public* repository, or
+ # - you are installing Scorecard on a *private* repository
+ # To create the PAT, follow the steps in https://github.com/ossf/scorecard-action?tab=readme-ov-file#authentication-with-fine-grained-pat-optional.
+ # repo_token: ${{ secrets.SCORECARD_TOKEN }}
+
+ # Public repositories:
+ # - Publish results to OpenSSF REST API for easy access by consumers
+ # - Allows the repository to include the Scorecard badge.
+ # - See https://github.com/ossf/scorecard-action#publishing-results.
+ # For private repositories:
+ # - `publish_results` will always be set to `false`, regardless
+ # of the value entered here.
+ publish_results: true
+
+ # (Optional) Uncomment file_mode if you have a .gitattributes with files marked export-ignore
+ # file_mode: git
+
+ # Upload the results as artifacts (optional). Commenting out will disable uploads of run results in SARIF
+ # format to the repository Actions tab.
+ - name: "Upload artifact"
+ uses: actions/upload-artifact@bbbca2ddaa5d8feaa63e36b76fdaad77386f024f # v7.0.0
+ with:
+ name: SARIF file
+ path: results.sarif
+ retention-days: 5
+
+ # Upload the results to GitHub's code scanning dashboard (optional).
+ # Commenting out will disable upload of results to your repo's Code Scanning dashboard
+ - name: "Upload to code-scanning"
+ uses: github/codeql-action/upload-sarif@38697555549f1db7851b81482ff19f1fa5c4fedc # v3
+ with:
+ sarif_file: results.sarif
diff --git a/.github/workflows/sonarcloud.yml b/.github/workflows/sonarcloud.yml
new file mode 100644
index 000000000..123b16f0a
--- /dev/null
+++ b/.github/workflows/sonarcloud.yml
@@ -0,0 +1,45 @@
+name: SonarCloud
+
+on:
+ push:
+ branches: [main]
+ pull_request:
+ branches: [main]
+
+permissions:
+ contents: read
+
+jobs:
+ sonarcloud:
+ name: SonarCloud Analysis
+ if: github.event.pull_request.head.repo.full_name == github.repository || github.event_name == 'push'
+ runs-on: ubuntu-latest
+ timeout-minutes: 15
+
+ steps:
+ - name: Checkout code
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
+ with:
+ fetch-depth: 0
+
+ - name: Install uv
+ uses: astral-sh/setup-uv@38f3f104447c67c051c4a08e39b64a148898af3a # v4
+ with:
+ enable-cache: true
+ cache-dependency-glob: "uv.lock"
+
+ - name: Set up Python
+ uses: actions/setup-python@a309ff8b426b58ec0e2a45f0f869d46889d02405 # v6.2.0
+ with:
+ python-version: "3.12"
+
+ - name: Install dependencies
+ run: uv sync --extra treesitter-full --extra test --extra semantic --group dev
+
+ - name: Run tests with coverage
+ run: uv run pytest -n auto -m "not integration" --tb=short --cov=codebase_rag --cov-report=xml
+
+ - name: SonarCloud Scan
+ uses: SonarSource/sonarqube-scan-action@fd88b7d7ccbaefd23d8f36f73b59db7a3d246602 # v6
+ env:
+ SONAR_TOKEN: ${{ secrets.SONAR_TOKEN }}
diff --git a/.github/workflows/split-score.yml b/.github/workflows/split-score.yml
new file mode 100644
index 000000000..7c65ac2e2
--- /dev/null
+++ b/.github/workflows/split-score.yml
@@ -0,0 +1,22 @@
+name: PR Split Score
+
+on:
+ pull_request:
+ branches: [main]
+
+permissions:
+ contents: read
+ pull-requests: write
+
+jobs:
+ score:
+ runs-on: ubuntu-latest
+ steps:
+ - uses: actions/checkout@v4
+ with:
+ fetch-depth: 0
+
+ - name: pr-split score
+ uses: vitali87/pr-split@v1.0.0
+ with:
+ max-loc: "400"
diff --git a/.github/workflows/version-bump.yml b/.github/workflows/version-bump.yml
index 0940adcad..596a01ccd 100644
--- a/.github/workflows/version-bump.yml
+++ b/.github/workflows/version-bump.yml
@@ -16,6 +16,8 @@ on:
- minor
- major
+permissions: read-all
+
jobs:
bump-version:
name: Auto Version Bump
@@ -26,7 +28,7 @@ jobs:
contents: write
steps:
- name: Checkout repository
- uses: actions/checkout@v4
+ uses: actions/checkout@de0fac2e4500dabe0009e67214ff5f5447ce83dd # v6.0.2
with:
fetch-depth: 2
token: ${{ secrets.GITHUB_TOKEN }}
@@ -90,12 +92,17 @@ jobs:
run: |
sed -i 's/^version = ".*"/version = "${{ steps.bump_version.outputs.new }}"/' pyproject.toml
+ - name: Update server.json
+ if: steps.check_manual.outputs.skip == 'false'
+ run: |
+ sed -i 's/"version": "[^"]*"/"version": "${{ steps.bump_version.outputs.new }}"/g' server.json
+
- name: Commit version bump
if: steps.check_manual.outputs.skip == 'false'
run: |
git config user.name "github-actions[bot]"
git config user.email "github-actions[bot]@users.noreply.github.com"
- git add pyproject.toml
+ git add pyproject.toml server.json
git commit -m "chore: bump version to ${{ steps.bump_version.outputs.new }}"
git push
diff --git a/.gitignore b/.gitignore
index 4b6211856..c44ce990d 100644
--- a/.gitignore
+++ b/.gitignore
@@ -23,3 +23,19 @@ PROJECT.md
.DS_Store
.pypi_cache.json
.omc
+site/
+
+# Eval harness scratch workspace (regenerated each run); result files are committed
+evals/results/l3_workspace/
+# Rust oracle build artifacts (the source + Cargo.lock are committed)
+evals/oracles/rs_oracle/target/
+# TypeScript oracle deps (the source + package-lock.json are committed)
+evals/oracles/ts_oracle/node_modules/
+# Java oracle compiled classes (the source is committed)
+evals/oracles/java_oracle/*.class
+# Lua oracle deps (the source + package-lock.json are committed)
+evals/oracles/lua_oracle/node_modules/
+# PHP oracle deps (the source + package-lock.json are committed)
+evals/oracles/php_oracle/node_modules/
+.cgr-hash-cache.json
+.cgr-dir-mtimes.json
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 92a09727a..12a7db5f0 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -5,23 +5,24 @@ repos:
- id: trailing-whitespace
- id: end-of-file-fixer
- id: check-yaml
+ args: [--unsafe]
- id: check-toml
- repo: https://github.com/astral-sh/ruff-pre-commit
rev: v0.12.2
hooks:
- id: ruff
args: [--fix, --exit-non-zero-on-fix]
- exclude: ^codec/schema_pb2\.(py|pyi)$
+ exclude: ^(codec/schema_pb2\.(py|pyi)|benchmarks/|optimize/)$
- id: ruff-format
- exclude: ^codec/schema_pb2\.(py|pyi)$
+ exclude: ^(codec/schema_pb2\.(py|pyi)|benchmarks/|optimize/)$
- repo: local
hooks:
- id: ty
name: ty check
- entry: uv run ty check --exclude codebase_rag/tests/
+ entry: uv run ty check --exclude codebase_rag/tests/ --exclude benchmarks/ --exclude optimize/ --exclude codec/ --exclude grammars/ --exclude query_modules/
language: system
types: [python]
- exclude: ^codec/.*_pb2\.py$
+ exclude: ^(codec/.*_pb2\.py|benchmarks/|optimize/|grammars/|query_modules/)$
pass_filenames: false
- repo: local
hooks:
@@ -30,7 +31,7 @@ repos:
entry: uv run python scripts/check_no_docs.py
language: system
types: [python]
- exclude: ^codec/schema_pb2\.py$
+ exclude: ^(codec/schema_pb2\.py|benchmarks/|optimize/)
- repo: local
hooks:
- id: generate-readme
@@ -45,7 +46,7 @@ repos:
- id: bandit
args: ["-c", "pyproject.toml", "--severity-level", "high"]
additional_dependencies: ["bandit[toml]"]
- exclude: ^(codebase_rag/tests/|scripts/)
+ exclude: ^(codebase_rag/tests/|scripts/|benchmarks/|optimize/)
- repo: https://github.com/compilerla/conventional-pre-commit
rev: v4.2.0
hooks:
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
new file mode 100644
index 000000000..9b47f9561
--- /dev/null
+++ b/CODE_OF_CONDUCT.md
@@ -0,0 +1,128 @@
+# Contributor Covenant Code of Conduct
+
+## Our Pledge
+
+We as members, contributors, and leaders pledge to make participation in our
+community a harassment-free experience for everyone, regardless of age, body
+size, visible or invisible disability, ethnicity, sex characteristics, gender
+identity and expression, level of experience, education, socio-economic status,
+nationality, personal appearance, race, religion, or sexual identity
+and orientation.
+
+We pledge to act and interact in ways that contribute to an open, welcoming,
+diverse, inclusive, and healthy community.
+
+## Our Standards
+
+Examples of behavior that contributes to a positive environment for our
+community include:
+
+* Demonstrating empathy and kindness toward other people
+* Being respectful of differing opinions, viewpoints, and experiences
+* Giving and gracefully accepting constructive feedback
+* Accepting responsibility and apologizing to those affected by our mistakes,
+ and learning from the experience
+* Focusing on what is best not just for us as individuals, but for the
+ overall community
+
+Examples of unacceptable behavior include:
+
+* The use of sexualized language or imagery, and sexual attention or
+ advances of any kind
+* Trolling, insulting or derogatory comments, and personal or political attacks
+* Public or private harassment
+* Publishing others' private information, such as a physical or email
+ address, without their explicit permission
+* Other conduct which could reasonably be considered inappropriate in a
+ professional setting
+
+## Enforcement Responsibilities
+
+Community leaders are responsible for clarifying and enforcing our standards of
+acceptable behavior and will take appropriate and fair corrective action in
+response to any behavior that they deem inappropriate, threatening, offensive,
+or harmful.
+
+Community leaders have the right and responsibility to remove, edit, or reject
+comments, commits, code, wiki edits, issues, and other contributions that are
+not aligned to this Code of Conduct, and will communicate reasons for moderation
+decisions when appropriate.
+
+## Scope
+
+This Code of Conduct applies within all community spaces, and also applies when
+an individual is officially representing the community in public spaces.
+Examples of representing our community include using an official e-mail address,
+posting via an official social media account, or acting as an appointed
+representative at an online or offline event.
+
+## Enforcement
+
+Instances of abusive, harassing, or otherwise unacceptable behavior may be
+reported to the community leaders responsible for enforcement at
+eheva87@gmail.com.
+All complaints will be reviewed and investigated promptly and fairly.
+
+All community leaders are obligated to respect the privacy and security of the
+reporter of any incident.
+
+## Enforcement Guidelines
+
+Community leaders will follow these Community Impact Guidelines in determining
+the consequences for any action they deem in violation of this Code of Conduct:
+
+### 1. Correction
+
+**Community Impact**: Use of inappropriate language or other behavior deemed
+unprofessional or unwelcome in the community.
+
+**Consequence**: A private, written warning from community leaders, providing
+clarity around the nature of the violation and an explanation of why the
+behavior was inappropriate. A public apology may be requested.
+
+### 2. Warning
+
+**Community Impact**: A violation through a single incident or series
+of actions.
+
+**Consequence**: A warning with consequences for continued behavior. No
+interaction with the people involved, including unsolicited interaction with
+those enforcing the Code of Conduct, for a specified period of time. This
+includes avoiding interactions in community spaces as well as external channels
+like social media. Violating these terms may lead to a temporary or
+permanent ban.
+
+### 3. Temporary Ban
+
+**Community Impact**: A serious violation of community standards, including
+sustained inappropriate behavior.
+
+**Consequence**: A temporary ban from any sort of interaction or public
+communication with the community for a specified period of time. No public or
+private interaction with the people involved, including unsolicited interaction
+with those enforcing the Code of Conduct, is allowed during this period.
+Violating these terms may lead to a permanent ban.
+
+### 4. Permanent Ban
+
+**Community Impact**: Demonstrating a pattern of violation of community
+standards, including sustained inappropriate behavior, harassment of an
+individual, or aggression toward or disparagement of classes of individuals.
+
+**Consequence**: A permanent ban from any sort of public interaction within
+the community.
+
+## Attribution
+
+This Code of Conduct is adapted from the [Contributor Covenant][homepage],
+version 2.0, available at
+https://www.contributor-covenant.org/version/2/0/code_of_conduct.html.
+
+Community Impact Guidelines were inspired by [Mozilla's code of conduct
+enforcement ladder](https://github.com/mozilla/diversity).
+
+[homepage]: https://www.contributor-covenant.org
+
+For answers to common questions about this code of conduct, see the FAQ at
+https://www.contributor-covenant.org/faq. Translations are available at
+https://www.contributor-covenant.org/translations.
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index cfc7c6d05..7d955c589 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -4,7 +4,7 @@ Thank you for your interest in contributing to Code Graph RAG! We welcome contri
## Getting Started
-1. **Browse Issues**: Check out our [GitHub Issues](https://github.com/vitali87/code-graph-rag/issues) to find tasks that need work
+1. **Browse Issues**: Check out our [issue tracker](https://codeberg.org/vitali87/code-graph-rag/issues) to find tasks that need work
- Look for issues labeled `good first issue` for beginner-friendly tasks
- Issues labeled `help wanted` are open for community contributions
2. **Pick an Issue**: Choose an issue that interests you and matches your skill level
diff --git a/Dockerfile b/Dockerfile
new file mode 100644
index 000000000..e965de91d
--- /dev/null
+++ b/Dockerfile
@@ -0,0 +1,51 @@
+FROM ghcr.io/astral-sh/uv:0.10@sha256:72ab0aeb448090480ccabb99fb5f52b0dc3c71923bffb5e2e26517a1c27b7fec AS uv
+
+FROM python:3.14-slim@sha256:fb83750094b46fd6b8adaa80f66e2302ecbe45d513f6cece637a841e1025b4ca AS builder
+
+COPY --from=uv /uv /uvx /bin/
+
+RUN apt-get update && \
+ apt-get install -y --no-install-recommends \
+ cmake build-essential libssl-dev zlib1g-dev libzstd-dev && \
+ rm -rf /var/lib/apt/lists/*
+
+WORKDIR /app
+
+COPY pyproject.toml uv.lock ./
+RUN uv sync --frozen --no-dev --extra treesitter-full --no-install-project --no-binary-package pymgclient
+
+COPY . .
+RUN uv sync --frozen --no-dev --extra treesitter-full --no-binary-package pymgclient
+
+FROM python:3.14-slim@sha256:fb83750094b46fd6b8adaa80f66e2302ecbe45d513f6cece637a841e1025b4ca
+
+RUN apt-get update && \
+ apt-get install -y --no-install-recommends ripgrep libssl3 zlib1g libzstd1 && \
+ rm -rf /var/lib/apt/lists/*
+
+RUN useradd --create-home appuser
+USER appuser
+WORKDIR /app
+
+COPY --from=builder --chown=appuser:appuser /app/.venv /app/.venv
+COPY --from=builder --chown=appuser:appuser /app/codebase_rag /app/codebase_rag
+COPY --from=builder --chown=appuser:appuser /app/codec /app/codec
+COPY --from=builder --chown=appuser:appuser /app/cgr /app/cgr
+COPY --from=builder --chown=appuser:appuser /app/pyproject.toml /app/pyproject.toml
+
+ENV PATH="/app/.venv/bin:$PATH"
+
+COPY --chmod=755 <<'EOF' /app/entrypoint.sh
+#!/bin/sh
+ARCH=$(uname -m)
+case "$ARCH" in
+ x86_64) LIBDIR="/lib/x86_64-linux-gnu" ;;
+ aarch64) LIBDIR="/lib/aarch64-linux-gnu" ;;
+ *) LIBDIR="/lib" ;;
+esac
+export LD_PRELOAD="$LIBDIR/libz.so.1:$LIBDIR/libzstd.so.1"
+exec code-graph-rag "$@"
+EOF
+
+ENTRYPOINT ["/app/entrypoint.sh"]
+CMD ["mcp-server"]
diff --git a/LICENSE b/LICENSE
index fd189113e..4765780e7 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
MIT License
-Copyright (c) [2025] [Vitali Avagyan]
+Copyright (c) 2025 Vitali Avagyan
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
diff --git a/Makefile b/Makefile
index 10c757dac..d8fa492d8 100644
--- a/Makefile
+++ b/Makefile
@@ -1,4 +1,4 @@
-.PHONY: help all install dev test test-parallel test-integration test-all test-parallel-all clean python build-grammars watch readme lint format typecheck check pre-commit
+.PHONY: help all install dev test test-parallel test-integration test-all test-parallel-all clean python build-grammars watch readme lint format typecheck check pre-commit release
PYTHON := uv run
@@ -77,6 +77,9 @@ typecheck: ## Run type checking with ty
check: lint typecheck test ## Run all checks: lint, typecheck, test
+release: ## Build, verify, and publish the current pyproject version to PyPI, then tag and create a GitHub Release
+ ./scripts/release.sh
+
pre-commit: ## Run all pre-commit checks locally (comprehensive test before commit)
@echo "Running pre-commit checks..."
@echo "1. Formatting code..."
diff --git a/PYPI_README.md b/PYPI_README.md
new file mode 100644
index 000000000..a1dd20c0b
--- /dev/null
+++ b/PYPI_README.md
@@ -0,0 +1,160 @@
+# Code-Graph-RAG
+
+A graph-based RAG system that parses multi-language codebases with Tree-sitter, builds knowledge graphs in Memgraph, and enables natural language querying, editing, and optimization.
+
+## Install
+
+```bash
+pip install code-graph-rag
+```
+
+With all Tree-sitter grammars (Python, JS, TS, Rust, Go, Java, Scala, C++, Lua):
+
+```bash
+pip install 'code-graph-rag[treesitter-full]'
+```
+
+With semantic code search (UniXcoder embeddings):
+
+```bash
+pip install 'code-graph-rag[semantic]'
+```
+
+### Prerequisites
+
+- Python 3.12+
+- Docker (for Memgraph)
+- `cmake` (for building pymgclient)
+- `ripgrep` (`rg`) (for shell command text searching)
+
+## CLI Quick Start
+
+The package installs a `cgr` command.
+
+**Start Memgraph, parse a repo, and query it:**
+
+```bash
+docker compose up -d # start Memgraph
+cgr start --repo-path ./my-project \
+ --update-graph --clean # parse & launch interactive chat
+```
+
+**Index to protobuf for offline use:**
+
+```bash
+cgr index -o ./index-output --repo-path ./my-project
+```
+
+**Export knowledge graph to JSON:**
+
+```bash
+cgr export -o graph.json
+```
+
+**AI-guided optimization:**
+
+```bash
+cgr optimize python --repo-path ./my-project
+```
+
+**Run as an MCP server (for Claude Code):**
+
+```bash
+cgr mcp-server
+```
+
+**Check your setup:**
+
+```bash
+cgr doctor
+```
+
+## Python SDK
+
+The `cgr` package provides short imports for programmatic use.
+
+### Load and query an exported graph
+
+```python
+from cgr import load_graph
+
+graph = load_graph("graph.json")
+print(graph.summary())
+
+functions = graph.find_nodes_by_label("Function")
+for fn in functions[:5]:
+ rels = graph.get_relationships_for_node(fn.node_id)
+ print(f"{fn.properties['name']}: {len(rels)} relationships")
+```
+
+### Query Memgraph with Cypher
+
+```python
+from cgr import MemgraphIngestor
+
+with MemgraphIngestor(host="localhost", port=7687) as db:
+ rows = db.fetch_all("MATCH (f:Function) RETURN f.name LIMIT 10")
+ for row in rows:
+ print(row)
+```
+
+### Generate Cypher from natural language
+
+```python
+import asyncio
+from cgr import CypherGenerator
+
+async def main():
+ gen = CypherGenerator()
+ cypher = await gen.generate("Find all classes that inherit from BaseModel")
+ print(cypher)
+
+asyncio.run(main())
+```
+
+### Semantic code search
+
+Requires the `semantic` extra.
+
+```python
+from cgr import embed_code
+
+embedding = embed_code("def authenticate(user, password): ...")
+print(f"Embedding dimension: {len(embedding)}")
+```
+
+### Configuration
+
+```python
+from cgr import settings
+
+settings.set_orchestrator("openai", "gpt-4o", api_key="sk-...")
+settings.set_cypher("google", "gemini-2.5-flash", api_key="your-key")
+```
+
+## Environment Variables
+
+Configure via `.env` or environment variables:
+
+| Variable | Default | Description |
+|----------|---------|-------------|
+| `MEMGRAPH_HOST` | `localhost` | Memgraph hostname |
+| `MEMGRAPH_PORT` | `7687` | Memgraph port |
+| `ORCHESTRATOR_PROVIDER` | | Provider: `google`, `openai`, `ollama` |
+| `ORCHESTRATOR_MODEL` | | Model ID (e.g. `gpt-4o`, `gemini-2.5-pro`) |
+| `ORCHESTRATOR_API_KEY` | | API key for the provider (not needed for `ollama`) |
+| `CYPHER_PROVIDER` | | Provider for Cypher generation |
+| `CYPHER_MODEL` | | Model ID for Cypher generation (e.g. `codellama`, `gpt-4o-mini`) |
+| `CYPHER_API_KEY` | | API key for Cypher provider (not needed for `ollama`) |
+| `TARGET_REPO_PATH` | `.` | Default repository path |
+
+## Documentation
+
+Full documentation, architecture details, and contribution guide:
+[docs.code-graph-rag.com](https://docs.code-graph-rag.com)
+
+## License
+
+MIT
+
+
diff --git a/README.md b/README.md
index 5ef87d4e0..46d6e6526 100644
--- a/README.md
+++ b/README.md
@@ -1,26 +1,54 @@
@@ -35,8 +63,9 @@ An accurate Retrieval-Augmented Generation (RAG) system that analyzes multi-lang
## Latest News 🔥
-- **[NEW]** **MCP Server Integration**: Code-Graph-RAG now works as an MCP server with Claude Code! Query and edit your codebase using natural language directly from Claude Code. [Setup Guide](docs/claude-code-setup.md)
-- [2025/10/21] **Semantic Code Search**: Added intent-based code search using UniXcoder embeddings. Find functions by describing what they do (e.g., "error handling functions", "authentication code") rather than by exact names.
+- **PHP Language Support**: Full PHP language support added — classes, interfaces, traits, enums, namespaces, PHP 8 attributes, and call graph analysis. Contributed by [@rs-ipps](https://github.com/rs-ipps).
+- **C Language Support**: Full C language support added — functions, structs, unions, enums, preprocessor includes, and call graph analysis. Contributed by [@dj0nes](https://github.com/dj0nes).
+- **Visualise any GitHub repo instantly!** Just change `github.com` to `gitcgr.com` in any repo URL — that's it, only 3 letters! Get an interactive graph of the entire codebase structure. Try it now: [gitcgr.com](https://gitcgr.com)
## 🚀 Features
@@ -45,16 +74,16 @@ An accurate Retrieval-Augmented Generation (RAG) system that analyzes multi-lang
| Language | Status | Extensions | Functions | Classes/Structs | Modules | Package Detection | Additional Features |
|--------|------|----------|---------|---------------|-------|-----------------|-------------------|
+| C | Fully Supported | .c | ✓ | ✓ | ✓ | ✓ | Functions, structs, unions, enums, preprocessor includes |
| C++ | Fully Supported | .cpp, .h, .hpp, .cc, .cxx, .hxx, .hh, .ixx, .cppm, .ccm | ✓ | ✓ | ✓ | ✓ | Constructors, destructors, operator overloading, templates, lambdas, C++20 modules, namespaces |
| Java | Fully Supported | .java | ✓ | ✓ | ✓ | - | Generics, annotations, modern features (records/sealed classes), concurrency, reflection |
| JavaScript | Fully Supported | .js, .jsx | ✓ | ✓ | ✓ | - | ES6 modules, CommonJS, prototype methods, object methods, arrow functions |
| Lua | Fully Supported | .lua | ✓ | - | ✓ | - | Local/global functions, metatables, closures, coroutines |
+| PHP | Fully Supported | .php | ✓ | ✓ | ✓ | - | Classes, interfaces, traits, enums, namespaces, PHP 8 attributes |
| Python | Fully Supported | .py | ✓ | ✓ | ✓ | ✓ | Type inference, decorators, nested functions |
| Rust | Fully Supported | .rs | ✓ | ✓ | ✓ | ✓ | impl blocks, associated functions |
| TypeScript | Fully Supported | .ts, .tsx | ✓ | ✓ | ✓ | - | Interfaces, type aliases, enums, namespaces, ES6/CommonJS modules |
-| C# | In Development | .cs | ✓ | ✓ | ✓ | - | Classes, interfaces, generics (planned) |
| Go | In Development | .go | ✓ | ✓ | ✓ | - | Methods, type declarations |
-| PHP | In Development | .php | ✓ | ✓ | ✓ | - | Classes, functions, namespaces |
| Scala | In Development | .scala, .sc | ✓ | ✓ | ✓ | - | Case classes, objects |
- **🌳 Tree-sitter Parsing**: Uses Tree-sitter for robust, language-agnostic AST parsing
@@ -111,9 +140,54 @@ sudo dnf install ripgrep
## 🛠️ Installation
+### System-wide install (recommended for end users)
+
+`cgr` is published to PyPI and can be installed system-wide so it works from any
+target repo without activating a project virtualenv. Install with the
+`treesitter-full` (all languages) and `semantic` (vector search) extras:
+
+```bash
+# with uv (recommended)
+uv tool install "code-graph-rag[treesitter-full,semantic]"
+
+# or with pipx
+pipx install "code-graph-rag[treesitter-full,semantic]"
+```
+
+For a Python-only install, omit the extras. For local development from a clone,
+use `uv tool install --editable "/path/to/code-graph-rag[treesitter-full,semantic]"`.
+
+After install, `cgr` is on PATH. From any repository, run:
+
```bash
-git clone https://github.com/vitali87/code-graph-rag.git
+cd ~/path/to/some-target-repo
+cgr daemon up # one-time: start the shared memgraph + qdrant stack
+cgr start # auto-sync the current repo and drop into the agent
+```
+
+`cgr start` defaults `--repo-path` to the current directory and auto-syncs the
+graph incrementally on entry. Pass `--no-sync` to skip the sync, or
+`--no-start-stack` if memgraph/qdrant already run elsewhere.
+
+Useful subcommands:
+
+| Command | Purpose |
+|---|---|
+| `cgr daemon up/down/status/restart/logs` | Manage the shared docker stack |
+| `cgr stop` | Alias for `cgr daemon down` |
+| `cgr status` | Show stack state + per-project last-sync timestamp |
+| `cgr workspace create/list/show/delete` | Manage named bundles of repos |
+| `cgr workspace add-repo / remove-repo` | Edit a workspace's repo set |
+| `cgr start --workspace mono` | Open the agent over every project in the workspace |
+| `cgr start --projects a,b,c` | Scope agent queries to the listed projects |
+Indexed data persists across `cgr daemon down` thanks to named memgraph + qdrant
+volumes (`memgraph_data`, `memgraph_log`, `qdrant_storage`).
+
+### Local development install
+
+```bash
+git clone https://codeberg.org/vitali87/code-graph-rag.git
cd code-graph-rag
```
@@ -218,9 +292,20 @@ ollama pull llama3.2
4. **Start Memgraph database**:
```bash
-docker-compose up -d
+docker compose up -d
+```
+
+5. **Verify installation**:
+```bash
+# If installed from PyPI:
+cgr --help
+
+# If running from source:
+uv run cgr --help
```
+> **Note**: When running from source (cloned repo), prefix all `cgr` commands below with `uv run`, e.g., `uv run cgr start ...`
+
## 🛠️ Makefile Commands
Use the Makefile for common development tasks:
@@ -246,6 +331,7 @@ Use the Makefile for common development tasks:
| `make format` | Run ruff format |
| `make typecheck` | Run type checking with ty |
| `make check` | Run all checks: lint, typecheck, test |
+| `make release` | Build, verify, and publish the current pyproject version to PyPI, then tag and create a GitHub Release |
| `make pre-commit` | Run all pre-commit checks locally (comprehensive test before commit) |
@@ -284,12 +370,23 @@ The system automatically detects and processes files for all supported languages
### Step 2: Query the Codebase
+**Interactive mode:**
+
Start the interactive RAG CLI:
```bash
cgr start --repo-path /path/to/your/repo
```
+**Non-interactive mode (single query):**
+
+Run a single query and exit, with output sent to stdout (useful for scripting):
+
+```bash
+python -m codebase_rag.main start --repo-path /path/to/your/repo \
+ --ask-agent "What functions call UserService.create_user?"
+```
+
### Step 2.5: Real-Time Graph Updates (Optional)
For active development, you can keep your knowledge graph automatically synchronized with code changes using the realtime updater. This is particularly useful when you're actively modifying code and want the AI assistant to always work with the latest codebase structure.
@@ -454,7 +551,7 @@ cgr optimize javascript --repo-path /path/to/frontend \
```
**Supported Languages for Optimization:**
-All supported languages: `python`, `javascript`, `typescript`, `rust`, `go`, `java`, `scala`, `cpp`
+All supported languages: `python`, `javascript`, `typescript`, `rust`, `go`, `java`, `scala`, `c`, `cpp`
**How It Works:**
1. **Analysis Phase**: The agent analyzes your codebase structure using the knowledge graph
@@ -532,13 +629,16 @@ claude mcp add --transport stdio code-graph-rag \
| `list_projects` | List all indexed projects in the knowledge graph database. Returns a list of project names that have been indexed. |
| `delete_project` | Delete a specific project from the knowledge graph database. This removes all nodes associated with the project while preserving other projects. Use list_projects first to see available projects. |
| `wipe_database` | WARNING: Completely wipe the entire database, removing ALL indexed projects. This cannot be undone. Use delete_project for removing individual projects. |
-| `index_repository` | Parse and ingest the repository into the Memgraph knowledge graph. This builds a comprehensive graph of functions, classes, dependencies, and relationships. Note: This preserves other projects - only the current project is re-indexed. |
-| `query_code_graph` | Query the codebase knowledge graph using natural language. Ask questions like 'What functions call UserService.create_user?' or 'Show me all classes that implement the Repository interface'. |
+| `index_repository` | WARNING: Clears all data for the current project including its embeddings. Parse and ingest the repository into the Memgraph knowledge graph. Use update_repository for incremental updates. Only use when explicitly requested. |
+| `update_repository` | Update the repository in the Memgraph knowledge graph without clearing existing data. Use this for incremental updates. |
+| `query_code_graph` | Query the codebase knowledge graph using natural language. Use semantic_search unless you know the exact names of classes/functions you are searching for. Ask questions like 'What functions call UserService.create_user?' or 'Show me all classes that implement the Repository interface'. |
| `get_code_snippet` | Retrieve source code for a function, class, or method by its qualified name. Returns the source code, file path, line numbers, and docstring. |
| `surgical_replace_code` | Surgically replace an exact code block in a file using diff-match-patch. Only modifies the exact target block, leaving the rest unchanged. |
| `read_file` | Read the contents of a file from the project. Supports pagination for large files. |
| `write_file` | Write content to a file, creating it if it doesn't exist. |
| `list_directory` | List contents of a directory in the project. |
+| `semantic_search` | Performs a semantic search for functions based on a natural language query describing their purpose, returning a list of potential matches with similarity scores. Requires the 'semantic' extra to be installed. |
+| `ask_agent` | Ask the Code Graph RAG agent a question about the codebase. Uses the full RAG pipeline to analyze the code graph and provide a detailed answer. Use this for general questions about architecture, functionality, and code relationships. |
### Example Usage
@@ -561,35 +661,35 @@ The knowledge graph uses the following node types and relationships:
| Label | Properties |
|-----|----------|
| Project | `{name: string}` |
-| Package | `{qualified_name: string, name: string, path: string}` |
-| Folder | `{path: string, name: string}` |
-| File | `{path: string, name: string, extension: string}` |
-| Module | `{qualified_name: string, name: string, path: string}` |
-| Class | `{qualified_name: string, name: string, decorators: list[string]}` |
-| Function | `{qualified_name: string, name: string, decorators: list[string]}` |
-| Method | `{qualified_name: string, name: string, decorators: list[string]}` |
-| Interface | `{qualified_name: string, name: string}` |
-| Enum | `{qualified_name: string, name: string}` |
+| Package | `{qualified_name: string, name: string, path: string, absolute_path: string}` |
+| Folder | `{path: string, name: string, absolute_path: string}` |
+| File | `{path: string, name: string, extension: string, absolute_path: string}` |
+| Module | `{qualified_name: string, name: string, path: string, absolute_path: string}` |
+| Class | `{qualified_name: string, name: string, decorators: list[string], path: string, absolute_path: string}` |
+| Function | `{qualified_name: string, name: string, decorators: list[string], path: string, absolute_path: string}` |
+| Method | `{qualified_name: string, name: string, decorators: list[string], path: string, absolute_path: string}` |
+| Interface | `{qualified_name: string, name: string, path: string, absolute_path: string}` |
+| Enum | `{qualified_name: string, name: string, path: string, absolute_path: string}` |
| Type | `{qualified_name: string, name: string}` |
| Union | `{qualified_name: string, name: string}` |
-| ModuleInterface | `{qualified_name: string, name: string, path: string}` |
-| ModuleImplementation | `{qualified_name: string, name: string, path: string, implements_module: string}` |
+| ModuleInterface | `{qualified_name: string, name: string, path: string, absolute_path: string}` |
+| ModuleImplementation | `{qualified_name: string, name: string, path: string, absolute_path: string, implements_module: string}` |
| ExternalPackage | `{name: string, version_spec: string}` |
### Language-Specific Mappings
+- **C**: `enum_specifier`, `function_definition`, `struct_specifier`, `union_specifier`
- **C++**: `class_specifier`, `declaration`, `enum_specifier`, `field_declaration`, `function_definition`, `lambda_expression`, `struct_specifier`, `template_declaration`, `union_specifier`
- **Java**: `annotation_type_declaration`, `class_declaration`, `constructor_declaration`, `enum_declaration`, `interface_declaration`, `method_declaration`, `record_declaration`
- **JavaScript**: `arrow_function`, `class`, `class_declaration`, `function_declaration`, `function_expression`, `generator_function_declaration`, `method_definition`
- **Lua**: `function_declaration`, `function_definition`
+- **PHP**: `anonymous_function`, `arrow_function`, `class_declaration`, `enum_declaration`, `function_definition`, `interface_declaration`, `method_declaration`, `trait_declaration`
- **Python**: `class_definition`, `function_definition`
- **Rust**: `closure_expression`, `enum_item`, `function_item`, `function_signature_item`, `impl_item`, `struct_item`, `trait_item`, `type_item`, `union_item`
- **TypeScript**: `abstract_class_declaration`, `arrow_function`, `class`, `class_declaration`, `enum_declaration`, `function_declaration`, `function_expression`, `function_signature`, `generator_function_declaration`, `interface_declaration`, `internal_module`, `method_definition`, `type_alias_declaration`
-- **C#**: `anonymous_method_expression`, `class_declaration`, `constructor_declaration`, `destructor_declaration`, `enum_declaration`, `function_pointer_type`, `interface_declaration`, `lambda_expression`, `local_function_statement`, `method_declaration`, `struct_declaration`
-- **Go**: `function_declaration`, `method_declaration`, `type_declaration`
-- **PHP**: `anonymous_function`, `arrow_function`, `class_declaration`, `enum_declaration`, `function_definition`, `function_static_declaration`, `interface_declaration`, `trait_declaration`
+- **Go**: `function_declaration`, `method_declaration`, `type_alias`, `type_spec`
- **Scala**: `class_definition`, `function_declaration`, `function_definition`, `object_definition`, `trait_definition`
@@ -614,6 +714,7 @@ The knowledge graph uses the following node types and relationships:
| ModuleImplementation | IMPLEMENTS | ModuleInterface |
| Project | DEPENDS_ON_EXTERNAL | ExternalPackage |
| Function, Method | CALLS | Function, Method |
+| Module, Function, Method | INSTANTIATES | Class |
## 🔧 Configuration
@@ -679,6 +780,7 @@ my_build_output
- **pydantic-settings**: Settings management using Pydantic
- **pymgclient**: Memgraph database adapter for Python language
- **python-dotenv**: Read key-value pairs from a .env file and set them as environment variables
+- **tiktoken**: tiktoken is a fast BPE tokeniser for use with OpenAI's models
- **toml**: Python Library for Tom's Obvious, Minimal Language
- **tree-sitter-python**: Python grammar for tree-sitter
- **tree-sitter**: Python bindings to the Tree-sitter parsing library
@@ -691,6 +793,7 @@ my_build_output
- **protobuf**
- **defusedxml**: XML bomb protection for Python stdlib modules
- **huggingface-hub**: Client library to download and publish models, datasets and other repos on the huggingface.co hub
+- **griffe**: Signatures for entire Python programs. Extract the structure, the frame, the skeleton of your project, to generate API documentation or find breaking changes in your API.
## 🤖 Agentic Workflow & Tools
@@ -705,11 +808,10 @@ The agent has access to a suite of tools to understand and interact with the cod
| Tool | Description |
|----|-----------|
| `query_graph` | Query the codebase knowledge graph using natural language questions. Ask in plain English about classes, functions, methods, dependencies, or code structure. Examples: 'Find all functions that call each other', 'What classes are in the user module', 'Show me functions with the longest call chains'. |
-| `read_file` | Reads the content of text-based files. For documents like PDFs or images, use the 'analyze_document' tool instead. |
+| `read_file` | Reads the content of text-based files. Images and PDFs the user references are attached inline; read them directly. |
| `create_file` | Creates a new file with content. IMPORTANT: Check file existence first! Overwrites completely WITHOUT showing diff. Use only for new files, not existing file modifications. |
| `replace_code` | Surgically replaces specific code blocks in files. Requires exact target code and replacement. Only modifies the specified block, leaving rest of file unchanged. True surgical patching. |
| `list_directory` | Lists the contents of a directory to explore the codebase. |
-| `analyze_document` | Analyzes documents (PDFs, images) to answer questions about their content. |
| `execute_shell` | Executes shell commands from allowlist. Read-only commands run without approval; write operations require user confirmation. |
| `semantic_search` | Performs a semantic search for functions based on a natural language query describing their purpose, returning a list of potential matches with similarity scores. |
| `get_function_source` | Retrieves the source code for a specific function or method using its internal node ID, typically obtained from a semantic search result. |
@@ -735,7 +837,7 @@ Code-Graph-RAG makes it easy to add support for any language that has a Tree-sit
> **⚠️ Recommendation**: While you can add languages yourself, we recommend waiting for official full support to ensure optimal parsing quality, comprehensive feature coverage, and robust integration. The languages marked as "In Development" above will receive dedicated optimization and testing.
-> **💡 Request Support**: If you want a specific language to be officially supported, please [submit an issue](https://github.com/vitali87/code-graph-rag/issues) with your language request.
+> **💡 Request Support**: If you want a specific language to be officially supported, please [submit an issue](https://codeberg.org/vitali87/code-graph-rag/issues) with your language request.
#### Quick Start: Add a Language
@@ -887,3 +989,7 @@ We also offer custom development, integration consulting, technical support cont
## Star History
[](https://www.star-history.com/#vitali87/code-graph-rag&Date)
+
+## Fork History
+
+[](https://fork-history.site/#vitali87/code-graph-rag)
diff --git a/SECURITY.md b/SECURITY.md
new file mode 100644
index 000000000..66299ab1b
--- /dev/null
+++ b/SECURITY.md
@@ -0,0 +1,46 @@
+# Security Policy
+
+## Supported Versions
+
+| Version | Supported |
+| ------- | ------------------ |
+| 0.0.x | :white_check_mark: |
+
+As the project is in early development (pre 1.0), only the latest release receives security updates. Please ensure you are running the most recent version before reporting a vulnerability.
+
+## Reporting a Vulnerability
+
+**Please do not report security vulnerabilities through public issues, pull requests, or any other public channels.**
+
+Instead, please open a [confidential issue](https://codeberg.org/vitali87/code-graph-rag/issues/new) on Codeberg (tick "this issue is confidential" before submitting). This ensures the details remain confidential until a fix is available.
+
+When reporting, please include:
+
+- A description of the vulnerability and its potential impact
+- Steps to reproduce or a proof of concept
+- The version(s) affected
+- Any suggested fix, if available
+
+## What to Expect
+
+- **Acknowledgement** within 72 hours of your report
+- **Status update** within 7 days with an initial assessment
+- **Resolution target** of 30 days for confirmed vulnerabilities, though critical issues will be prioritized for faster turnaround
+
+If the vulnerability is accepted, we will work on a fix, coordinate disclosure with you, and credit you in the release notes (unless you prefer to remain anonymous).
+
+If the vulnerability is declined, we will provide a clear explanation of why.
+
+## Scope
+
+This policy applies to the `code-graph-rag` Python package and its official repository. Third party dependencies are outside the direct scope of this policy, though we use Dependabot to monitor and update them.
+
+## Security Measures in This Project
+
+- **Dependency scanning**: Dependabot is enabled for automated dependency updates
+- **Secret scanning**: GitHub secret scanning is active on this repository
+- **Branch protection**: The `main` branch requires pull request reviews before merging
+
+## Preferred Languages
+
+We accept security reports in English.
diff --git a/benchmarks/bench_ast_cache.py b/benchmarks/bench_ast_cache.py
new file mode 100644
index 000000000..b1e3e65d9
--- /dev/null
+++ b/benchmarks/bench_ast_cache.py
@@ -0,0 +1,134 @@
+import statistics
+import sys
+import time
+from collections import OrderedDict
+from pathlib import Path
+
+WARMUP_RUNS = 3
+BENCH_RUNS = 50
+
+
+class MockNode:
+ __slots__ = ("data",)
+
+ def __init__(self, size: int) -> None:
+ self.data = b"\x00" * size
+
+
+def bench_ordered_dict_insert(count: int, item_size: int) -> float:
+ start = time.perf_counter()
+ cache: OrderedDict[Path, tuple[MockNode, str]] = OrderedDict()
+ for i in range(count):
+ key = Path(f"/fake/path/module_{i}.py")
+ cache[key] = (MockNode(item_size), "python")
+ return time.perf_counter() - start
+
+
+def bench_ordered_dict_lookup(cache: OrderedDict, keys: list[Path]) -> float:
+ start = time.perf_counter()
+ for key in keys:
+ _ = key in cache
+ return time.perf_counter() - start
+
+
+def bench_ordered_dict_access_lru(cache: OrderedDict, keys: list[Path]) -> float:
+ start = time.perf_counter()
+ for key in keys:
+ if key in cache:
+ cache.move_to_end(key)
+ _ = cache[key]
+ return time.perf_counter() - start
+
+
+def bench_ordered_dict_eviction(count: int, max_size: int, item_size: int) -> float:
+ start = time.perf_counter()
+ cache: OrderedDict[Path, tuple[MockNode, str]] = OrderedDict()
+ for i in range(count):
+ key = Path(f"/fake/path/module_{i}.py")
+ cache[key] = (MockNode(item_size), "python")
+ while len(cache) > max_size:
+ cache.popitem(last=False)
+ return time.perf_counter() - start
+
+
+def bench_getsizeof_overhead(cache: OrderedDict) -> float:
+ start = time.perf_counter()
+ _ = sum(sys.getsizeof(v) for v in cache.values())
+ return time.perf_counter() - start
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<45} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 115)
+ for r in results:
+ print(
+ f"{r['name']:<45} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def main() -> None:
+ configs = [
+ (500, 1024),
+ (2000, 4096),
+ (5000, 8192),
+ ]
+
+ for count, item_size in configs:
+ print(f"\n{'='*115}")
+ print(f"BoundedASTCache Benchmark (entries={count}, item_size={item_size}B)")
+ print(f"{'='*115}")
+
+ results = []
+
+ r = run_benchmark(f"insert ({count})", bench_ordered_dict_insert, count, item_size)
+ results.append(r)
+
+ cache: OrderedDict[Path, tuple[MockNode, str]] = OrderedDict()
+ keys: list[Path] = []
+ for i in range(count):
+ key = Path(f"/fake/path/module_{i}.py")
+ keys.append(key)
+ cache[key] = (MockNode(item_size), "python")
+
+ r = run_benchmark(f"lookup ({count})", bench_ordered_dict_lookup, cache, keys)
+ results.append(r)
+
+ r = run_benchmark(f"access+LRU ({count})", bench_ordered_dict_access_lru, cache, keys)
+ results.append(r)
+
+ max_size = count // 2
+ r = run_benchmark(
+ f"insert+evict (max={max_size})",
+ bench_ordered_dict_eviction, count, max_size, item_size,
+ )
+ results.append(r)
+
+ r = run_benchmark(f"getsizeof scan ({count})", bench_getsizeof_overhead, cache)
+ results.append(r)
+
+ print_results(results)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/bench_dropin_replacements.py b/benchmarks/bench_dropin_replacements.py
new file mode 100644
index 000000000..ee4eb0b0a
--- /dev/null
+++ b/benchmarks/bench_dropin_replacements.py
@@ -0,0 +1,267 @@
+import hashlib
+import json
+import os
+import statistics
+import tempfile
+import time
+from pathlib import Path
+
+try:
+ import blake3
+ import orjson
+except ImportError as e:
+ print(f"SKIP bench_dropin_replacements: {e}")
+ print("Install with: uv pip install blake3 orjson")
+ raise SystemExit(0)
+
+WARMUP_RUNS = 3
+BENCH_RUNS = 30
+
+
+def generate_graph_data(num_nodes: int, num_rels: int) -> dict:
+ nodes = []
+ for i in range(num_nodes):
+ nodes.append({
+ "node_id": i,
+ "labels": ["Function" if i % 3 == 0 else "Class" if i % 3 == 1 else "Module"],
+ "properties": {
+ "qualified_name": f"project.module{i // 100}.Class{i // 10}.method{i}",
+ "name": f"method{i}",
+ "start_line": i * 10,
+ "end_line": i * 10 + 9,
+ "docstring": f"Method {i} documentation string with some content" if i % 5 == 0 else None,
+ "decorators": ["staticmethod"] if i % 7 == 0 else [],
+ "is_exported": i % 4 == 0,
+ },
+ })
+
+ rels = []
+ for i in range(num_rels):
+ rels.append({
+ "from_id": i % num_nodes,
+ "to_id": (i * 7 + 3) % num_nodes,
+ "type": "CALLS" if i % 3 == 0 else "DEFINES" if i % 3 == 1 else "IMPORTS",
+ "properties": {"weight": i % 10} if i % 5 == 0 else {},
+ })
+
+ return {
+ "nodes": nodes,
+ "relationships": rels,
+ "metadata": {
+ "total_nodes": num_nodes,
+ "total_relationships": num_rels,
+ "exported_at": "2026-03-14T10:00:00+00:00",
+ },
+ }
+
+
+def generate_snippets(count: int, avg_length: int = 200) -> list[str]:
+ import random
+ import string
+ random.seed(42)
+ snippets = []
+ for _ in range(count):
+ length = avg_length + random.randint(-50, 50)
+ snippet = "".join(random.choices(string.ascii_letters + string.digits + " \n\t", k=length))
+ snippets.append(snippet)
+ return snippets
+
+
+def create_test_files(directory: str, count: int, avg_size_kb: int) -> list[Path]:
+ paths = []
+ for i in range(count):
+ path = Path(directory) / f"file_{i}.py"
+ content = os.urandom(avg_size_kb * 1024)
+ path.write_bytes(content)
+ paths.append(path)
+ return paths
+
+
+def bench_json_dumps(data: dict) -> float:
+ start = time.perf_counter()
+ _ = json.dumps(data)
+ return time.perf_counter() - start
+
+
+def bench_orjson_dumps(data: dict) -> float:
+ start = time.perf_counter()
+ _ = orjson.dumps(data)
+ return time.perf_counter() - start
+
+
+def bench_json_dumps_indent(data: dict) -> float:
+ start = time.perf_counter()
+ _ = json.dumps(data, indent=2, ensure_ascii=False)
+ return time.perf_counter() - start
+
+
+def bench_orjson_dumps_indent(data: dict) -> float:
+ start = time.perf_counter()
+ _ = orjson.dumps(data, option=orjson.OPT_INDENT_2)
+ return time.perf_counter() - start
+
+
+def bench_json_loads(json_bytes: bytes) -> float:
+ start = time.perf_counter()
+ _ = json.loads(json_bytes)
+ return time.perf_counter() - start
+
+
+def bench_orjson_loads(json_bytes: bytes) -> float:
+ start = time.perf_counter()
+ _ = orjson.loads(json_bytes)
+ return time.perf_counter() - start
+
+
+def bench_sha256_hashing(snippets: list[str]) -> float:
+ start = time.perf_counter()
+ for s in snippets:
+ _ = hashlib.sha256(s.encode()).hexdigest()
+ return time.perf_counter() - start
+
+
+def bench_blake3_hashing(snippets: list[str]) -> float:
+ start = time.perf_counter()
+ for s in snippets:
+ _ = blake3.blake3(s.encode()).hexdigest()
+ return time.perf_counter() - start
+
+
+def bench_sha256_file(files: list[Path]) -> float:
+ start = time.perf_counter()
+ for f in files:
+ hasher = hashlib.sha256()
+ with f.open("rb") as fh:
+ while chunk := fh.read(8192):
+ hasher.update(chunk)
+ _ = hasher.hexdigest()
+ return time.perf_counter() - start
+
+
+def bench_blake3_file(files: list[Path]) -> float:
+ start = time.perf_counter()
+ for f in files:
+ hasher = blake3.blake3()
+ with f.open("rb") as fh:
+ while chunk := fh.read(8192):
+ hasher.update(chunk)
+ _ = hasher.hexdigest()
+ return time.perf_counter() - start
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<50} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 120)
+ for r in results:
+ print(
+ f"{r['name']:<50} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def print_comparison(baseline: dict[str, float], optimized: dict[str, float]) -> None:
+ speedup = baseline["median_ms"] / optimized["median_ms"] if optimized["median_ms"] > 0 else float("inf")
+ print(f" -> Speedup: {speedup:.1f}x (median)")
+
+
+def main() -> None:
+ print("=" * 120)
+ print("DROP-IN REPLACEMENT BENCHMARKS: Python stdlib vs Rust-backed alternatives")
+ print("=" * 120)
+
+ # --- JSON Serialization ---
+ for num_nodes, num_rels in [(1000, 2000), (5000, 10000), (20000, 50000)]:
+ print(f"\n{'='*120}")
+ print(f"JSON Serialization: stdlib json vs orjson (nodes={num_nodes}, rels={num_rels})")
+ print(f"{'='*120}")
+
+ data = generate_graph_data(num_nodes, num_rels)
+ json_bytes = json.dumps(data).encode()
+ orjson_bytes = orjson.dumps(data)
+ print(f"Data size: {len(json_bytes) / 1024:.1f} KB")
+
+ results = []
+
+ r1 = run_benchmark(f"json.dumps compact ({num_nodes}n)", bench_json_dumps, data)
+ results.append(r1)
+ r2 = run_benchmark(f"orjson.dumps compact ({num_nodes}n)", bench_orjson_dumps, data)
+ results.append(r2)
+
+ r3 = run_benchmark(f"json.dumps indented ({num_nodes}n)", bench_json_dumps_indent, data)
+ results.append(r3)
+ r4 = run_benchmark(f"orjson.dumps indented ({num_nodes}n)", bench_orjson_dumps_indent, data)
+ results.append(r4)
+
+ r5 = run_benchmark(f"json.loads ({num_nodes}n)", bench_json_loads, json_bytes)
+ results.append(r5)
+ r6 = run_benchmark(f"orjson.loads ({num_nodes}n)", bench_orjson_loads, orjson_bytes)
+ results.append(r6)
+
+ print_results(results)
+
+ print("\nSpeedups:")
+ print(f" dumps compact: {r1['median_ms'] / r2['median_ms']:.1f}x")
+ print(f" dumps indented: {r3['median_ms'] / r4['median_ms']:.1f}x")
+ print(f" loads: {r5['median_ms'] / r6['median_ms']:.1f}x")
+
+ # --- Hashing: SHA256 vs BLAKE3 ---
+ print(f"\n\n{'='*120}")
+ print("Hashing: hashlib.sha256 vs blake3 (snippet hashing for EmbeddingCache)")
+ print(f"{'='*120}")
+
+ for size in [500, 2000, 10000]:
+ snippets = generate_snippets(size)
+ print(f"\n--- Snippet count: {size} ---")
+
+ results = []
+ r1 = run_benchmark(f"hashlib.sha256 ({size} snippets)", bench_sha256_hashing, snippets)
+ results.append(r1)
+ r2 = run_benchmark(f"blake3 ({size} snippets)", bench_blake3_hashing, snippets)
+ results.append(r2)
+
+ print_results(results)
+ print(f" Speedup: {r1['median_ms'] / r2['median_ms']:.1f}x")
+
+ # --- File Hashing ---
+ print(f"\n\n{'='*120}")
+ print("File Hashing: SHA256 vs BLAKE3 (incremental build file change detection)")
+ print(f"{'='*120}")
+
+ for file_count, avg_size_kb in [(50, 5), (200, 10), (500, 20)]:
+ with tempfile.TemporaryDirectory() as tmpdir:
+ files = create_test_files(tmpdir, file_count, avg_size_kb)
+ total_mb = sum(f.stat().st_size for f in files) / (1024 * 1024)
+ print(f"\n--- Files: {file_count}, Total: {total_mb:.1f} MB ---")
+
+ results = []
+ r1 = run_benchmark(f"sha256 ({file_count}f, {avg_size_kb}KB avg)", bench_sha256_file, files)
+ results.append(r1)
+ r2 = run_benchmark(f"blake3 ({file_count}f, {avg_size_kb}KB avg)", bench_blake3_file, files)
+ results.append(r2)
+
+ print_results(results)
+ print(f" Speedup: {r1['median_ms'] / r2['median_ms']:.1f}x")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/bench_embedding_cache.py b/benchmarks/bench_embedding_cache.py
new file mode 100644
index 000000000..b63e93338
--- /dev/null
+++ b/benchmarks/bench_embedding_cache.py
@@ -0,0 +1,130 @@
+import hashlib
+import random
+import statistics
+import string
+import time
+
+from codebase_rag.embedder import EmbeddingCache
+
+WARMUP_RUNS = 3
+BENCH_RUNS = 50
+EMBEDDING_DIM = 768
+
+
+def generate_snippets(count: int, avg_length: int = 200) -> list[str]:
+ snippets = []
+ for i in range(count):
+ length = avg_length + random.randint(-50, 50)
+ snippet = "".join(random.choices(string.ascii_letters + string.digits + " \n\t", k=length))
+ snippets.append(snippet)
+ return snippets
+
+
+def generate_embedding() -> list[float]:
+ return [random.random() for _ in range(EMBEDDING_DIM)]
+
+
+def bench_sha256_hashing(snippets: list[str]) -> float:
+ start = time.perf_counter()
+ for s in snippets:
+ _ = hashlib.sha256(s.encode()).hexdigest()
+ return time.perf_counter() - start
+
+
+def bench_cache_put(cache: EmbeddingCache, snippets: list[str], embeddings: list[list[float]]) -> float:
+ start = time.perf_counter()
+ for s, e in zip(snippets, embeddings):
+ cache.put(s, e)
+ return time.perf_counter() - start
+
+
+def bench_cache_get_hit(cache: EmbeddingCache, snippets: list[str]) -> float:
+ start = time.perf_counter()
+ for s in snippets:
+ _ = cache.get(s)
+ return time.perf_counter() - start
+
+
+def bench_cache_get_miss(cache: EmbeddingCache, miss_snippets: list[str]) -> float:
+ start = time.perf_counter()
+ for s in miss_snippets:
+ _ = cache.get(s)
+ return time.perf_counter() - start
+
+
+def bench_cache_get_many(cache: EmbeddingCache, snippets: list[str]) -> float:
+ start = time.perf_counter()
+ _ = cache.get_many(snippets)
+ return time.perf_counter() - start
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<40} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 110)
+ for r in results:
+ print(
+ f"{r['name']:<40} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def main() -> None:
+ random.seed(42)
+
+ sizes = [500, 2000, 10000]
+
+ for size in sizes:
+ print(f"\n{'='*110}")
+ print(f"EmbeddingCache Benchmark (n={size})")
+ print(f"{'='*110}")
+
+ snippets = generate_snippets(size)
+ embeddings = [generate_embedding() for _ in range(size)]
+ miss_snippets = generate_snippets(size, avg_length=300)
+
+ results = []
+
+ r = run_benchmark(f"sha256 hashing ({size})", bench_sha256_hashing, snippets)
+ results.append(r)
+
+ cache = EmbeddingCache()
+ r = run_benchmark(f"cache.put ({size})", bench_cache_put, cache, snippets, embeddings)
+ results.append(r)
+
+ cache = EmbeddingCache()
+ cache.put_many(snippets, embeddings)
+
+ r = run_benchmark(f"cache.get hit ({size})", bench_cache_get_hit, cache, snippets)
+ results.append(r)
+
+ r = run_benchmark(f"cache.get miss ({size})", bench_cache_get_miss, cache, miss_snippets)
+ results.append(r)
+
+ r = run_benchmark(f"cache.get_many ({size})", bench_cache_get_many, cache, snippets)
+ results.append(r)
+
+ print_results(results)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/bench_file_hashing.py b/benchmarks/bench_file_hashing.py
new file mode 100644
index 000000000..3be76059b
--- /dev/null
+++ b/benchmarks/bench_file_hashing.py
@@ -0,0 +1,138 @@
+import hashlib
+import os
+import statistics
+import tempfile
+import time
+from pathlib import Path
+
+WARMUP_RUNS = 3
+BENCH_RUNS = 30
+
+
+def create_test_files(directory: str, count: int, avg_size_kb: int) -> list[Path]:
+ paths = []
+ for i in range(count):
+ path = Path(directory) / f"file_{i}.py"
+ content = os.urandom(avg_size_kb * 1024)
+ path.write_bytes(content)
+ paths.append(path)
+ return paths
+
+
+def hash_file_sha256(filepath: Path) -> str:
+ hasher = hashlib.sha256()
+ with filepath.open("rb") as f:
+ while chunk := f.read(8192):
+ hasher.update(chunk)
+ return hasher.hexdigest()
+
+
+def hash_file_sha256_large_buffer(filepath: Path) -> str:
+ hasher = hashlib.sha256()
+ with filepath.open("rb") as f:
+ while chunk := f.read(65536):
+ hasher.update(chunk)
+ return hasher.hexdigest()
+
+
+def hash_file_sha256_mmap(filepath: Path) -> str:
+ import mmap
+ hasher = hashlib.sha256()
+ with filepath.open("rb") as f:
+ with mmap.mmap(f.fileno(), 0, access=mmap.ACCESS_READ) as mm:
+ hasher.update(mm)
+ return hasher.hexdigest()
+
+
+def hash_file_md5(filepath: Path) -> str:
+ hasher = hashlib.md5()
+ with filepath.open("rb") as f:
+ while chunk := f.read(8192):
+ hasher.update(chunk)
+ return hasher.hexdigest()
+
+
+def hash_file_blake2b(filepath: Path) -> str:
+ hasher = hashlib.blake2b()
+ with filepath.open("rb") as f:
+ while chunk := f.read(8192):
+ hasher.update(chunk)
+ return hasher.hexdigest()
+
+
+def bench_hash_files(files: list[Path], hash_func) -> float:
+ start = time.perf_counter()
+ for f in files:
+ _ = hash_func(f)
+ return time.perf_counter() - start
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<45} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 115)
+ for r in results:
+ print(
+ f"{r['name']:<45} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def main() -> None:
+ configs = [
+ (50, 5),
+ (200, 10),
+ (500, 20),
+ ]
+
+ for file_count, avg_size_kb in configs:
+ print(f"\n{'='*115}")
+ print(f"File Hashing Benchmark (files={file_count}, avg_size={avg_size_kb}KB)")
+ print(f"{'='*115}")
+
+ with tempfile.TemporaryDirectory() as tmpdir:
+ files = create_test_files(tmpdir, file_count, avg_size_kb)
+ total_mb = sum(f.stat().st_size for f in files) / (1024 * 1024)
+ print(f"Total data: {total_mb:.1f} MB")
+
+ results = []
+
+ r = run_benchmark(f"sha256 8KB buf ({file_count}f)", bench_hash_files, files, hash_file_sha256)
+ results.append(r)
+
+ r = run_benchmark(f"sha256 64KB buf ({file_count}f)", bench_hash_files, files, hash_file_sha256_large_buffer)
+ results.append(r)
+
+ r = run_benchmark(f"sha256 mmap ({file_count}f)", bench_hash_files, files, hash_file_sha256_mmap)
+ results.append(r)
+
+ r = run_benchmark(f"md5 ({file_count}f)", bench_hash_files, files, hash_file_md5)
+ results.append(r)
+
+ r = run_benchmark(f"blake2b ({file_count}f)", bench_hash_files, files, hash_file_blake2b)
+ results.append(r)
+
+ print_results(results)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/bench_find_ending_with_fix.py b/benchmarks/bench_find_ending_with_fix.py
new file mode 100644
index 000000000..c9ef01cae
--- /dev/null
+++ b/benchmarks/bench_find_ending_with_fix.py
@@ -0,0 +1,218 @@
+import statistics
+import time
+from collections import defaultdict
+
+from codebase_rag.graph_updater import FunctionRegistryTrie
+from codebase_rag.types_defs import NodeType, SimpleNameLookup
+
+WARMUP_RUNS = 3
+BENCH_RUNS = 30
+
+
+def generate_realistic_registry(count: int) -> tuple[list[str], list[str]]:
+ modules = ["codebase_rag", "utils", "parsers", "services", "tools", "models"]
+ submodules = ["core", "api", "handlers", "helpers", "base", "factory"]
+ classes = ["Handler", "Manager", "Factory", "Builder", "Processor", "Resolver",
+ "Analyzer", "Extractor", "Generator", "Validator"]
+ methods = ["process", "handle", "create", "build", "resolve", "validate",
+ "execute", "parse", "extract", "transform", "analyze", "generate",
+ "find", "get", "set", "update", "delete", "check"]
+
+ qualified_names = []
+ for i in range(count):
+ mod = modules[i % len(modules)]
+ sub = submodules[(i // len(modules)) % len(submodules)]
+ cls = classes[(i // (len(modules) * len(submodules))) % len(classes)]
+ meth = methods[(i // (len(modules) * len(submodules) * len(classes))) % len(methods)]
+ qualified_names.append(f"{mod}.{sub}.{cls}.method_{i}.{meth}")
+
+ lookup_suffixes = methods + [f"method_{i}" for i in range(0, count, count // 20)]
+ return qualified_names, lookup_suffixes
+
+
+def bench_linear_scan_endswith(entries: dict[str, NodeType], suffix: str) -> float:
+ start = time.perf_counter()
+ _ = [qn for qn in entries.keys() if qn.endswith(f".{suffix}")]
+ return time.perf_counter() - start
+
+
+def bench_indexed_lookup(lookup: SimpleNameLookup, suffix: str) -> float:
+ start = time.perf_counter()
+ _ = list(lookup.get(suffix, set()))
+ return time.perf_counter() - start
+
+
+def bench_trie_find_ending_with_index_hit(
+ trie: FunctionRegistryTrie, suffixes: list[str], indexed_suffixes: set[str]
+) -> float:
+ start = time.perf_counter()
+ for suffix in suffixes:
+ if suffix in indexed_suffixes:
+ _ = trie.find_ending_with(suffix)
+ return time.perf_counter() - start
+
+
+def bench_trie_find_ending_with_index_miss(
+ trie: FunctionRegistryTrie, suffixes: list[str], indexed_suffixes: set[str]
+) -> float:
+ start = time.perf_counter()
+ for suffix in suffixes:
+ if suffix not in indexed_suffixes:
+ _ = trie.find_ending_with(suffix)
+ return time.perf_counter() - start
+
+
+def bench_trie_find_ending_with_all(
+ trie: FunctionRegistryTrie, suffixes: list[str]
+) -> float:
+ start = time.perf_counter()
+ for suffix in suffixes:
+ _ = trie.find_ending_with(suffix)
+ return time.perf_counter() - start
+
+
+def bench_linear_scan_batch(entries: dict[str, NodeType], suffixes: list[str]) -> float:
+ start = time.perf_counter()
+ for suffix in suffixes:
+ _ = [qn for qn in entries.keys() if qn.endswith(f".{suffix}")]
+ return time.perf_counter() - start
+
+
+def bench_indexed_lookup_batch(lookup: SimpleNameLookup, suffixes: list[str]) -> float:
+ start = time.perf_counter()
+ for suffix in suffixes:
+ _ = list(lookup.get(suffix, set()))
+ return time.perf_counter() - start
+
+
+def bench_full_suffix_index_batch(
+ suffix_index: dict[str, set[str]], suffixes: list[str]
+) -> float:
+ start = time.perf_counter()
+ for suffix in suffixes:
+ _ = list(suffix_index.get(suffix, set()))
+ return time.perf_counter() - start
+
+
+def build_full_suffix_index(qualified_names: list[str]) -> dict[str, set[str]]:
+ index: dict[str, set[str]] = defaultdict(set)
+ for qn in qualified_names:
+ simple_name = qn.rsplit(".", 1)[-1]
+ index[simple_name].add(qn)
+ return dict(index)
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<55} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 125)
+ for r in results:
+ print(
+ f"{r['name']:<55} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def main() -> None:
+ print("=" * 125)
+ print("find_ending_with FIX BENCHMARK: Linear Scan vs Indexed Lookup")
+ print("This benchmarks the #1 CPU hotspot (48.3% of total runtime)")
+ print("=" * 125)
+
+ sizes = [1000, 4500, 10000]
+
+ for size in sizes:
+ print(f"\n{'='*125}")
+ print(f"Registry size: {size} entries")
+ print(f"{'='*125}")
+
+ qualified_names, lookup_suffixes = generate_realistic_registry(size)
+
+ simple_lookup: SimpleNameLookup = defaultdict(set)
+ trie = FunctionRegistryTrie(simple_name_lookup=simple_lookup)
+ for qn in qualified_names:
+ trie.insert(qn, NodeType.FUNCTION)
+ simple_name = qn.rsplit(".", 1)[-1]
+ simple_lookup[simple_name].add(qn)
+
+ full_suffix_index = build_full_suffix_index(qualified_names)
+
+ partially_indexed_suffixes = set(list(simple_lookup.keys())[:len(simple_lookup) // 5])
+ miss_suffixes = [s for s in lookup_suffixes if s not in partially_indexed_suffixes]
+
+ results = []
+
+ print(f"\nSingle-suffix operations (on '{lookup_suffixes[0]}'):")
+ r = run_benchmark(
+ f"LINEAR SCAN endswith ({size} entries)",
+ bench_linear_scan_endswith, dict(trie.items()), lookup_suffixes[0],
+ )
+ results.append(r)
+
+ r = run_benchmark(
+ f"INDEXED lookup (hit) ({size} entries)",
+ bench_indexed_lookup, simple_lookup, lookup_suffixes[0],
+ )
+ results.append(r)
+
+ print_results(results)
+ if results[1]["median_ms"] > 0:
+ speedup = results[0]["median_ms"] / results[1]["median_ms"]
+ print(f"\n -> Index hit speedup: {speedup:.0f}x")
+
+ results = []
+ num_queries = len(lookup_suffixes)
+ print(f"\nBatch operations ({num_queries} queries, simulating call resolution):")
+
+ r = run_benchmark(
+ f"LINEAR SCAN batch ({num_queries}q, {size} entries)",
+ bench_linear_scan_batch, dict(trie.items()), lookup_suffixes,
+ )
+ results.append(r)
+
+ r = run_benchmark(
+ f"PARTIAL INDEX batch ({num_queries}q, {size} entries)",
+ bench_trie_find_ending_with_all, trie, lookup_suffixes,
+ )
+ results.append(r)
+
+ r = run_benchmark(
+ f"FULL SUFFIX INDEX batch ({num_queries}q, {size} entries)",
+ bench_full_suffix_index_batch, full_suffix_index, lookup_suffixes,
+ )
+ results.append(r)
+
+ print_results(results)
+
+ if results[2]["median_ms"] > 0:
+ print(f"\n -> Linear scan vs full index: {results[0]['median_ms'] / results[2]['median_ms']:.0f}x speedup")
+ print(f" -> Partial index vs full index: {results[1]['median_ms'] / results[2]['median_ms']:.1f}x speedup")
+
+ print(f"\n\n{'='*125}")
+ print("CONCLUSION: The 48.3% CPU hotspot is caused by linear scans on index misses.")
+ print("Building a complete suffix index eliminates the bottleneck entirely.")
+ print("This is a pure Python fix requiring zero FFI, zero new dependencies.")
+ print(f"{'='*125}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/bench_graph_loader.py b/benchmarks/bench_graph_loader.py
new file mode 100644
index 000000000..f93ccd7a4
--- /dev/null
+++ b/benchmarks/bench_graph_loader.py
@@ -0,0 +1,169 @@
+import json
+import statistics
+import tempfile
+import time
+from pathlib import Path
+
+from codebase_rag.graph_loader import GraphLoader
+
+WARMUP_RUNS = 2
+BENCH_RUNS = 20
+
+
+def generate_graph_json(num_nodes: int, num_rels: int) -> str:
+ nodes = []
+ for i in range(num_nodes):
+ nodes.append({
+ "node_id": i,
+ "labels": ["Function" if i % 3 == 0 else "Class" if i % 3 == 1 else "Module"],
+ "properties": {
+ "qualified_name": f"project.module{i // 100}.Class{i // 10}.method{i}",
+ "name": f"method{i}",
+ "start_line": i * 10,
+ "end_line": i * 10 + 9,
+ },
+ })
+
+ rels = []
+ for i in range(num_rels):
+ rels.append({
+ "from_id": i % num_nodes,
+ "to_id": (i * 7 + 3) % num_nodes,
+ "type": "CALLS" if i % 2 == 0 else "DEFINES",
+ "properties": {},
+ })
+
+ graph = {
+ "nodes": nodes,
+ "relationships": rels,
+ "metadata": {
+ "total_nodes": num_nodes,
+ "total_relationships": num_rels,
+ },
+ }
+ return json.dumps(graph)
+
+
+def bench_json_parse(json_str: str) -> float:
+ start = time.perf_counter()
+ _ = json.loads(json_str)
+ return time.perf_counter() - start
+
+
+def bench_graph_load(file_path: str) -> float:
+ start = time.perf_counter()
+ loader = GraphLoader(file_path)
+ loader.load()
+ return time.perf_counter() - start
+
+
+def bench_find_nodes_by_label(loader: GraphLoader) -> float:
+ labels = ["Function", "Class", "Module"]
+ start = time.perf_counter()
+ for label in labels:
+ _ = loader.find_nodes_by_label(label)
+ return time.perf_counter() - start
+
+
+def bench_find_node_by_property(loader: GraphLoader) -> float:
+ start = time.perf_counter()
+ for i in range(100):
+ qn = f"project.module{i}.Class{i * 10 // 10}.method{i * 10}"
+ _ = loader.find_node_by_property("qualified_name", qn)
+ return time.perf_counter() - start
+
+
+def bench_get_relationships(loader: GraphLoader, num_nodes: int) -> float:
+ start = time.perf_counter()
+ for i in range(min(500, num_nodes)):
+ _ = loader.get_relationships_for_node(i)
+ return time.perf_counter() - start
+
+
+def bench_summary(loader: GraphLoader) -> float:
+ start = time.perf_counter()
+ _ = loader.summary()
+ return time.perf_counter() - start
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<40} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 110)
+ for r in results:
+ print(
+ f"{r['name']:<40} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def main() -> None:
+ configs = [
+ (1000, 2000),
+ (5000, 10000),
+ (20000, 50000),
+ ]
+
+ for num_nodes, num_rels in configs:
+ print(f"\n{'='*110}")
+ print(f"GraphLoader Benchmark (nodes={num_nodes}, rels={num_rels})")
+ print(f"{'='*110}")
+
+ json_str = generate_graph_json(num_nodes, num_rels)
+ print(f"JSON size: {len(json_str) / 1024:.1f} KB")
+
+ with tempfile.NamedTemporaryFile(
+ mode="w", suffix=".json", delete=False
+ ) as tmp:
+ tmp.write(json_str)
+ tmp_path = tmp.name
+
+ results = []
+
+ r = run_benchmark(f"json.loads ({num_nodes}n)", bench_json_parse, json_str)
+ results.append(r)
+
+ r = run_benchmark(f"GraphLoader.load ({num_nodes}n)", bench_graph_load, tmp_path)
+ results.append(r)
+
+ loader = GraphLoader(tmp_path)
+ loader.load()
+
+ r = run_benchmark(f"find_nodes_by_label ({num_nodes}n)", bench_find_nodes_by_label, loader)
+ results.append(r)
+
+ r = run_benchmark(f"find_node_by_property ({num_nodes}n)", bench_find_node_by_property, loader)
+ results.append(r)
+
+ r = run_benchmark(f"get_relationships ({num_nodes}n)", bench_get_relationships, loader, num_nodes)
+ results.append(r)
+
+ r = run_benchmark(f"summary ({num_nodes}n)", bench_summary, loader)
+ results.append(r)
+
+ print_results(results)
+
+ Path(tmp_path).unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/bench_json_serialization.py b/benchmarks/bench_json_serialization.py
new file mode 100644
index 000000000..98fc477f7
--- /dev/null
+++ b/benchmarks/bench_json_serialization.py
@@ -0,0 +1,159 @@
+import json
+import statistics
+import tempfile
+import time
+from pathlib import Path
+
+WARMUP_RUNS = 3
+BENCH_RUNS = 20
+
+
+def generate_graph_data(num_nodes: int, num_rels: int) -> dict:
+ nodes = []
+ for i in range(num_nodes):
+ nodes.append({
+ "id": i,
+ "labels": ["Function" if i % 3 == 0 else "Class" if i % 3 == 1 else "Module"],
+ "properties": {
+ "qualified_name": f"project.module{i // 100}.Class{i // 10}.method{i}",
+ "name": f"method{i}",
+ "start_line": i * 10,
+ "end_line": i * 10 + 9,
+ "docstring": f"Method {i} documentation string with some content" if i % 5 == 0 else None,
+ "decorators": ["staticmethod"] if i % 7 == 0 else [],
+ "is_exported": i % 4 == 0,
+ },
+ })
+
+ rels = []
+ for i in range(num_rels):
+ rels.append({
+ "from_id": i % num_nodes,
+ "to_id": (i * 7 + 3) % num_nodes,
+ "type": "CALLS" if i % 3 == 0 else "DEFINES" if i % 3 == 1 else "IMPORTS",
+ "properties": {"weight": i % 10} if i % 5 == 0 else {},
+ })
+
+ return {
+ "nodes": nodes,
+ "relationships": rels,
+ "metadata": {
+ "total_nodes": num_nodes,
+ "total_relationships": num_rels,
+ "exported_at": "2026-03-14T10:00:00+00:00",
+ },
+ }
+
+
+def bench_json_dumps(data: dict) -> float:
+ start = time.perf_counter()
+ _ = json.dumps(data)
+ return time.perf_counter() - start
+
+
+def bench_json_dumps_indent(data: dict) -> float:
+ start = time.perf_counter()
+ _ = json.dumps(data, indent=2, ensure_ascii=False)
+ return time.perf_counter() - start
+
+
+def bench_json_loads(json_str: str) -> float:
+ start = time.perf_counter()
+ _ = json.loads(json_str)
+ return time.perf_counter() - start
+
+
+def bench_json_dump_file(data: dict, path: str) -> float:
+ start = time.perf_counter()
+ with open(path, "w", encoding="utf-8") as f:
+ json.dump(data, f, indent=2, ensure_ascii=False)
+ return time.perf_counter() - start
+
+
+def bench_json_load_file(path: str) -> float:
+ start = time.perf_counter()
+ with open(path, encoding="utf-8") as f:
+ _ = json.load(f)
+ return time.perf_counter() - start
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<45} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 115)
+ for r in results:
+ print(
+ f"{r['name']:<45} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def main() -> None:
+ configs = [
+ (1000, 2000),
+ (5000, 10000),
+ (20000, 50000),
+ ]
+
+ for num_nodes, num_rels in configs:
+ print(f"\n{'='*115}")
+ print(f"JSON Serialization Benchmark (nodes={num_nodes}, rels={num_rels})")
+ print(f"{'='*115}")
+
+ data = generate_graph_data(num_nodes, num_rels)
+ json_str = json.dumps(data)
+ json_str_indented = json.dumps(data, indent=2, ensure_ascii=False)
+ print(f"Compact JSON: {len(json_str) / 1024:.1f} KB, Indented: {len(json_str_indented) / 1024:.1f} KB")
+
+ with tempfile.NamedTemporaryFile(
+ mode="w", suffix=".json", delete=False
+ ) as tmp:
+ json.dump(data, tmp, indent=2, ensure_ascii=False)
+ tmp_path = tmp.name
+
+ results = []
+
+ r = run_benchmark(f"json.dumps compact ({num_nodes}n)", bench_json_dumps, data)
+ results.append(r)
+
+ r = run_benchmark(f"json.dumps indented ({num_nodes}n)", bench_json_dumps_indent, data)
+ results.append(r)
+
+ r = run_benchmark(f"json.loads compact ({num_nodes}n)", bench_json_loads, json_str)
+ results.append(r)
+
+ r = run_benchmark(f"json.loads indented ({num_nodes}n)", bench_json_loads, json_str_indented)
+ results.append(r)
+
+ r = run_benchmark(f"json.dump to file ({num_nodes}n)", bench_json_dump_file, data, tmp_path)
+ results.append(r)
+
+ r = run_benchmark(f"json.load from file ({num_nodes}n)", bench_json_load_file, tmp_path)
+ results.append(r)
+
+ print_results(results)
+
+ Path(tmp_path).unlink(missing_ok=True)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/bench_pathlib_vs_string.py b/benchmarks/bench_pathlib_vs_string.py
new file mode 100644
index 000000000..1794b2cef
--- /dev/null
+++ b/benchmarks/bench_pathlib_vs_string.py
@@ -0,0 +1,214 @@
+import os
+import statistics
+import time
+from pathlib import Path, PurePosixPath
+
+WARMUP_RUNS = 3
+BENCH_RUNS = 50
+
+
+def generate_file_paths(repo_root: str, count: int) -> list[str]:
+ dirs = ["src", "lib", "utils", "core", "parsers", "services", "tools", "tests"]
+ subdirs = ["base", "handlers", "helpers", "models", "schemas", "config"]
+ extensions = [".py", ".js", ".ts", ".rs", ".go", ".java", ".cpp"]
+
+ paths = []
+ for i in range(count):
+ d = dirs[i % len(dirs)]
+ sd = subdirs[(i // len(dirs)) % len(subdirs)]
+ ext = extensions[(i // (len(dirs) * len(subdirs))) % len(extensions)]
+ paths.append(f"{repo_root}/{d}/{sd}/module_{i}{ext}")
+ return paths
+
+
+def generate_skip_patterns() -> list[str]:
+ return [
+ "node_modules", ".git", "__pycache__", ".venv", "dist", "build",
+ ".mypy_cache", ".pytest_cache", ".tox", "egg-info",
+ ]
+
+
+def bench_pathlib_relative_to(paths: list[str], repo_root: str) -> float:
+ repo_path = Path(repo_root)
+ start = time.perf_counter()
+ for p in paths:
+ path = Path(p)
+ _ = path.relative_to(repo_path)
+ return time.perf_counter() - start
+
+
+def bench_string_removeprefix(paths: list[str], repo_root: str) -> float:
+ prefix = repo_root + "/"
+ start = time.perf_counter()
+ for p in paths:
+ _ = p.removeprefix(prefix)
+ return time.perf_counter() - start
+
+
+def bench_os_path_relpath(paths: list[str], repo_root: str) -> float:
+ start = time.perf_counter()
+ for p in paths:
+ _ = os.path.relpath(p, repo_root)
+ return time.perf_counter() - start
+
+
+def bench_pathlib_should_skip(paths: list[str], repo_root: str, skip_patterns: list[str]) -> float:
+ repo_path = Path(repo_root)
+ skip_set = set(skip_patterns)
+ start = time.perf_counter()
+ for p in paths:
+ path = Path(p)
+ try:
+ relative = path.relative_to(repo_path)
+ parts = relative.parts
+ _ = any(part in skip_set for part in parts)
+ except ValueError:
+ pass
+ return time.perf_counter() - start
+
+
+def bench_string_should_skip(paths: list[str], repo_root: str, skip_patterns: list[str]) -> float:
+ prefix = repo_root + "/"
+ skip_set = set(skip_patterns)
+ start = time.perf_counter()
+ for p in paths:
+ relative = p.removeprefix(prefix)
+ parts = relative.split("/")
+ _ = any(part in skip_set for part in parts)
+ return time.perf_counter() - start
+
+
+def bench_pathlib_suffix_check(paths: list[str]) -> float:
+ start = time.perf_counter()
+ for p in paths:
+ path = Path(p)
+ _ = path.suffix
+ return time.perf_counter() - start
+
+
+def bench_string_suffix_check(paths: list[str]) -> float:
+ start = time.perf_counter()
+ for p in paths:
+ dot_idx = p.rfind(".")
+ _ = p[dot_idx:] if dot_idx >= 0 else ""
+ return time.perf_counter() - start
+
+
+def bench_os_path_splitext(paths: list[str]) -> float:
+ start = time.perf_counter()
+ for p in paths:
+ _, _ = os.path.splitext(p)
+ return time.perf_counter() - start
+
+
+def bench_pathlib_name(paths: list[str]) -> float:
+ start = time.perf_counter()
+ for p in paths:
+ path = Path(p)
+ _ = path.name
+ return time.perf_counter() - start
+
+
+def bench_string_name(paths: list[str]) -> float:
+ start = time.perf_counter()
+ for p in paths:
+ slash_idx = p.rfind("/")
+ _ = p[slash_idx + 1:] if slash_idx >= 0 else p
+ return time.perf_counter() - start
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<55} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 125)
+ for r in results:
+ print(
+ f"{r['name']:<55} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def main() -> None:
+ print("=" * 125)
+ print("pathlib vs String Operations Benchmark")
+ print("This benchmarks the #2 CPU hotspot (13.7% of total runtime)")
+ print("=" * 125)
+
+ repo_root = "/Users/developer/projects/large-repo"
+ skip_patterns = generate_skip_patterns()
+
+ for count in [1000, 5000, 20000, 59012]:
+ print(f"\n{'='*125}")
+ print(f"Path count: {count} (59012 = actual profiled call count)")
+ print(f"{'='*125}")
+
+ paths = generate_file_paths(repo_root, count)
+
+ results = []
+
+ print("\n--- relative_to vs removeprefix ---")
+ r1 = run_benchmark(f"pathlib.relative_to ({count}p)", bench_pathlib_relative_to, paths, repo_root)
+ results.append(r1)
+ r2 = run_benchmark(f"str.removeprefix ({count}p)", bench_string_removeprefix, paths, repo_root)
+ results.append(r2)
+ r3 = run_benchmark(f"os.path.relpath ({count}p)", bench_os_path_relpath, paths, repo_root)
+ results.append(r3)
+
+ print_results(results)
+ print(f"\n -> pathlib vs str.removeprefix: {r1['median_ms'] / r2['median_ms']:.0f}x slower")
+ print(f" -> pathlib vs os.path.relpath: {r1['median_ms'] / r3['median_ms']:.1f}x slower")
+
+ results = []
+ print("\n--- should_skip_path (full function) ---")
+ r1 = run_benchmark(f"pathlib should_skip ({count}p)", bench_pathlib_should_skip, paths, repo_root, skip_patterns)
+ results.append(r1)
+ r2 = run_benchmark(f"string should_skip ({count}p)", bench_string_should_skip, paths, repo_root, skip_patterns)
+ results.append(r2)
+
+ print_results(results)
+ print(f"\n -> pathlib vs string: {r1['median_ms'] / r2['median_ms']:.1f}x slower")
+
+ results = []
+ print("\n--- Suffix/extension extraction ---")
+ r1 = run_benchmark(f"Path.suffix ({count}p)", bench_pathlib_suffix_check, paths)
+ results.append(r1)
+ r2 = run_benchmark(f"str.rfind ({count}p)", bench_string_suffix_check, paths)
+ results.append(r2)
+ r3 = run_benchmark(f"os.path.splitext ({count}p)", bench_os_path_splitext, paths)
+ results.append(r3)
+
+ print_results(results)
+ print(f"\n -> Path.suffix vs str.rfind: {r1['median_ms'] / r2['median_ms']:.1f}x slower")
+
+ results = []
+ print("\n--- Filename extraction ---")
+ r1 = run_benchmark(f"Path.name ({count}p)", bench_pathlib_name, paths)
+ results.append(r1)
+ r2 = run_benchmark(f"str.rfind+slice ({count}p)", bench_string_name, paths)
+ results.append(r2)
+
+ print_results(results)
+ print(f"\n -> Path.name vs str: {r1['median_ms'] / r2['median_ms']:.1f}x slower")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/bench_string_ops.py b/benchmarks/bench_string_ops.py
new file mode 100644
index 000000000..cc10e91f8
--- /dev/null
+++ b/benchmarks/bench_string_ops.py
@@ -0,0 +1,148 @@
+import re
+import statistics
+import time
+
+WARMUP_RUNS = 3
+BENCH_RUNS = 100
+
+SEPARATOR_PATTERN = re.compile(r"[.:]|::")
+
+
+def generate_qualified_names(count: int) -> list[str]:
+ names = []
+ modules = ["project", "utils", "core", "api", "services", "models"]
+ classes = ["Handler", "Manager", "Factory", "Builder", "Processor", "Resolver"]
+ methods = ["process", "handle", "create", "build", "resolve", "validate"]
+ for i in range(count):
+ mod = modules[i % len(modules)]
+ cls = classes[(i // len(modules)) % len(classes)]
+ meth = methods[(i // (len(modules) * len(classes))) % len(methods)]
+ names.append(f"{mod}.{cls}.sub{i}.{meth}")
+ return names
+
+
+def bench_str_split(names: list[str]) -> float:
+ start = time.perf_counter()
+ for name in names:
+ _ = name.split(".")
+ return time.perf_counter() - start
+
+
+def bench_str_endswith(names: list[str]) -> float:
+ suffixes = [".process", ".handle", ".create", ".build", ".resolve"]
+ start = time.perf_counter()
+ for name in names:
+ for suffix in suffixes:
+ _ = name.endswith(suffix)
+ return time.perf_counter() - start
+
+
+def bench_str_startswith(names: list[str]) -> float:
+ prefixes = ["project.", "utils.", "core.", "api."]
+ start = time.perf_counter()
+ for name in names:
+ for prefix in prefixes:
+ _ = name.startswith(prefix)
+ return time.perf_counter() - start
+
+
+def bench_str_join(names: list[str]) -> float:
+ split_names = [name.split(".") for name in names]
+ start = time.perf_counter()
+ for parts in split_names:
+ _ = ".".join(parts)
+ return time.perf_counter() - start
+
+
+def bench_str_replace(names: list[str]) -> float:
+ start = time.perf_counter()
+ for name in names:
+ _ = name.replace("/", ".")
+ return time.perf_counter() - start
+
+
+def bench_regex_split(names: list[str]) -> float:
+ start = time.perf_counter()
+ for name in names:
+ _ = SEPARATOR_PATTERN.split(name)
+ return time.perf_counter() - start
+
+
+def bench_str_format(names: list[str]) -> float:
+ start = time.perf_counter()
+ for name in names:
+ _ = f"module.{name}.method"
+ return time.perf_counter() - start
+
+
+def bench_import_distance(names: list[str]) -> float:
+ start = time.perf_counter()
+ for i in range(0, len(names) - 1, 2):
+ caller_parts = names[i].split(".")
+ candidate_parts = names[i + 1].split(".")
+ common = 0
+ for j in range(min(len(caller_parts), len(candidate_parts))):
+ if caller_parts[j] == candidate_parts[j]:
+ common += 1
+ else:
+ break
+ _ = max(len(caller_parts), len(candidate_parts)) - common
+ return time.perf_counter() - start
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<40} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 110)
+ for r in results:
+ print(
+ f"{r['name']:<40} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def main() -> None:
+ sizes = [1000, 5000, 20000]
+
+ for size in sizes:
+ print(f"\n{'='*110}")
+ print(f"String Operations Benchmark (n={size})")
+ print(f"{'='*110}")
+
+ names = generate_qualified_names(size)
+
+ results = [
+ run_benchmark(f"str.split ({size})", bench_str_split, names),
+ run_benchmark(f"str.endswith ({size})", bench_str_endswith, names),
+ run_benchmark(f"str.startswith ({size})", bench_str_startswith, names),
+ run_benchmark(f"str.join ({size})", bench_str_join, names),
+ run_benchmark(f"str.replace ({size})", bench_str_replace, names),
+ run_benchmark(f"regex split ({size})", bench_regex_split, names),
+ run_benchmark(f"f-string format ({size})", bench_str_format, names),
+ run_benchmark(f"import_distance ({size})", bench_import_distance, names),
+ ]
+
+ print_results(results)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/bench_trie.py b/benchmarks/bench_trie.py
new file mode 100644
index 000000000..dba339100
--- /dev/null
+++ b/benchmarks/bench_trie.py
@@ -0,0 +1,138 @@
+import statistics
+import time
+from collections import defaultdict
+
+from codebase_rag.graph_updater import FunctionRegistryTrie
+from codebase_rag.types_defs import NodeType, SimpleNameLookup
+
+WARMUP_RUNS = 3
+BENCH_RUNS = 50
+
+
+def generate_qualified_names(count: int) -> list[str]:
+ names = []
+ modules = ["project", "utils", "core", "api", "services", "models"]
+ classes = ["Handler", "Manager", "Factory", "Builder", "Processor", "Resolver"]
+ methods = ["process", "handle", "create", "build", "resolve", "validate", "execute"]
+ for i in range(count):
+ mod = modules[i % len(modules)]
+ cls = classes[(i // len(modules)) % len(classes)]
+ meth = methods[(i // (len(modules) * len(classes))) % len(methods)]
+ sub = f"sub{i}"
+ names.append(f"{mod}.{cls}.{sub}.{meth}")
+ return names
+
+
+def bench_insert(trie: FunctionRegistryTrie, names: list[str]) -> float:
+ start = time.perf_counter()
+ for name in names:
+ trie.insert(name, NodeType.FUNCTION)
+ return time.perf_counter() - start
+
+
+def bench_lookup(trie: FunctionRegistryTrie, names: list[str]) -> float:
+ start = time.perf_counter()
+ for name in names:
+ _ = name in trie
+ return time.perf_counter() - start
+
+
+def bench_find_ending_with(trie: FunctionRegistryTrie) -> float:
+ suffixes = ["process", "handle", "create", "build", "resolve", "validate", "execute"]
+ start = time.perf_counter()
+ for suffix in suffixes:
+ _ = trie.find_ending_with(suffix)
+ return time.perf_counter() - start
+
+
+def bench_find_with_prefix(trie: FunctionRegistryTrie) -> float:
+ prefixes = ["project", "utils", "core", "api", "services", "models"]
+ start = time.perf_counter()
+ for prefix in prefixes:
+ _ = trie.find_with_prefix(prefix)
+ return time.perf_counter() - start
+
+
+def bench_delete(names: list[str]) -> float:
+ simple_lookup: SimpleNameLookup = defaultdict(set)
+ trie = FunctionRegistryTrie(simple_name_lookup=simple_lookup)
+ for name in names:
+ trie.insert(name, NodeType.FUNCTION)
+ simple_name = name.split(".")[-1]
+ simple_lookup[simple_name].add(name)
+
+ start = time.perf_counter()
+ for name in names[:len(names) // 4]:
+ del trie[name]
+ return time.perf_counter() - start
+
+
+def run_benchmark(name: str, func, *args) -> dict[str, float]:
+ for _ in range(WARMUP_RUNS):
+ func(*args)
+
+ times = []
+ for _ in range(BENCH_RUNS):
+ times.append(func(*args))
+
+ return {
+ "name": name,
+ "median_ms": statistics.median(times) * 1000,
+ "mean_ms": statistics.mean(times) * 1000,
+ "stddev_ms": statistics.stdev(times) * 1000 if len(times) > 1 else 0,
+ "min_ms": min(times) * 1000,
+ "max_ms": max(times) * 1000,
+ "p95_ms": sorted(times)[int(len(times) * 0.95)] * 1000,
+ }
+
+
+def print_results(results: list[dict[str, float]]) -> None:
+ print(f"\n{'Benchmark':<35} {'Median':>10} {'Mean':>10} {'StdDev':>10} {'Min':>10} {'Max':>10} {'P95':>10}")
+ print("-" * 105)
+ for r in results:
+ print(
+ f"{r['name']:<35} {r['median_ms']:>9.3f}ms {r['mean_ms']:>9.3f}ms "
+ f"{r['stddev_ms']:>9.3f}ms {r['min_ms']:>9.3f}ms {r['max_ms']:>9.3f}ms "
+ f"{r['p95_ms']:>9.3f}ms"
+ )
+
+
+def main() -> None:
+ sizes = [1000, 5000, 10000, 50000]
+
+ for size in sizes:
+ print(f"\n{'='*105}")
+ print(f"FunctionRegistryTrie Benchmark (n={size})")
+ print(f"{'='*105}")
+
+ names = generate_qualified_names(size)
+
+ simple_lookup: SimpleNameLookup = defaultdict(set)
+ trie = FunctionRegistryTrie(simple_name_lookup=simple_lookup)
+
+ results = []
+
+ r = run_benchmark(f"insert ({size})", bench_insert, trie, names)
+ results.append(r)
+
+ for name in names:
+ simple_name = name.split(".")[-1]
+ simple_lookup[simple_name].add(name)
+
+ r = run_benchmark(f"lookup ({size})", bench_lookup, trie, names)
+ results.append(r)
+
+ r = run_benchmark(f"find_ending_with ({size})", bench_find_ending_with, trie)
+ results.append(r)
+
+ r = run_benchmark(f"find_with_prefix ({size})", bench_find_with_prefix, trie)
+ results.append(r)
+
+ r = run_benchmark(f"delete 25% ({size})", bench_delete, names)
+ results.append(r)
+
+ print_results(results)
+
+
+if __name__ == "__main__":
+ main()
diff --git a/benchmarks/results/bench_ast_cache_20260315_000043.txt b/benchmarks/results/bench_ast_cache_20260315_000043.txt
new file mode 100644
index 000000000..5084d79ef
--- /dev/null
+++ b/benchmarks/results/bench_ast_cache_20260315_000043.txt
@@ -0,0 +1,42 @@
+Benchmark: bench_ast_cache.py
+Timestamp: 20260315_000043
+Exit code: 0
+Duration: 2.2s
+Python: 3.12.2 (main, Feb 25 2024, 03:55:42) [Clang 17.0.6 ]
+================================================================================
+
+===================================================================================================================
+BoundedASTCache Benchmark (entries=500, item_size=1024B)
+===================================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+-------------------------------------------------------------------------------------------------------------------
+insert (500) 1.119ms 1.128ms 0.020ms 1.113ms 1.229ms 1.158ms
+lookup (500) 0.019ms 0.019ms 0.000ms 0.018ms 0.019ms 0.019ms
+access+LRU (500) 0.053ms 0.053ms 0.000ms 0.053ms 0.056ms 0.053ms
+insert+evict (max=250) 1.141ms 1.155ms 0.092ms 1.133ms 1.792ms 1.158ms
+getsizeof scan (500) 0.062ms 0.062ms 0.001ms 0.061ms 0.067ms 0.062ms
+
+===================================================================================================================
+BoundedASTCache Benchmark (entries=2000, item_size=4096B)
+===================================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+-------------------------------------------------------------------------------------------------------------------
+insert (2000) 4.717ms 4.798ms 0.248ms 4.591ms 5.567ms 5.558ms
+lookup (2000) 0.077ms 0.077ms 0.000ms 0.076ms 0.078ms 0.077ms
+access+LRU (2000) 0.214ms 0.214ms 0.001ms 0.213ms 0.217ms 0.216ms
+insert+evict (max=1000) 4.768ms 4.814ms 0.221ms 4.614ms 5.870ms 5.103ms
+getsizeof scan (2000) 0.257ms 0.259ms 0.005ms 0.254ms 0.279ms 0.269ms
+
+===================================================================================================================
+BoundedASTCache Benchmark (entries=5000, item_size=8192B)
+===================================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+-------------------------------------------------------------------------------------------------------------------
+insert (5000) 12.829ms 13.137ms 0.611ms 12.561ms 14.340ms 14.280ms
+lookup (5000) 0.206ms 0.206ms 0.002ms 0.203ms 0.210ms 0.209ms
+access+LRU (5000) 0.551ms 0.552ms 0.005ms 0.544ms 0.565ms 0.563ms
+insert+evict (max=2500) 12.558ms 12.992ms 0.936ms 12.246ms 16.534ms 14.787ms
+getsizeof scan (5000) 0.681ms 0.686ms 0.027ms 0.651ms 0.812ms 0.740ms
diff --git a/benchmarks/results/bench_embedding_cache_20260315_000043.txt b/benchmarks/results/bench_embedding_cache_20260315_000043.txt
new file mode 100644
index 000000000..807a58402
--- /dev/null
+++ b/benchmarks/results/bench_embedding_cache_20260315_000043.txt
@@ -0,0 +1,42 @@
+Benchmark: bench_embedding_cache.py
+Timestamp: 20260315_000043
+Exit code: 0
+Duration: 3.4s
+Python: 3.12.2 (main, Feb 25 2024, 03:55:42) [Clang 17.0.6 ]
+================================================================================
+
+==============================================================================================================
+EmbeddingCache Benchmark (n=500)
+==============================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+--------------------------------------------------------------------------------------------------------------
+sha256 hashing (500) 0.155ms 0.151ms 0.006ms 0.143ms 0.161ms 0.159ms
+cache.put (500) 0.182ms 0.182ms 0.002ms 0.179ms 0.187ms 0.185ms
+cache.get hit (500) 0.177ms 0.177ms 0.001ms 0.176ms 0.180ms 0.179ms
+cache.get miss (500) 0.190ms 0.192ms 0.003ms 0.189ms 0.207ms 0.195ms
+cache.get_many (500) 0.190ms 0.190ms 0.001ms 0.189ms 0.193ms 0.191ms
+
+==============================================================================================================
+EmbeddingCache Benchmark (n=2000)
+==============================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+--------------------------------------------------------------------------------------------------------------
+sha256 hashing (2000) 0.562ms 0.564ms 0.006ms 0.557ms 0.581ms 0.576ms
+cache.put (2000) 0.751ms 0.760ms 0.027ms 0.738ms 0.918ms 0.794ms
+cache.get hit (2000) 0.729ms 0.732ms 0.009ms 0.719ms 0.765ms 0.748ms
+cache.get miss (2000) 0.797ms 0.801ms 0.026ms 0.771ms 0.866ms 0.839ms
+cache.get_many (2000) 0.798ms 0.808ms 0.028ms 0.777ms 0.888ms 0.856ms
+
+==============================================================================================================
+EmbeddingCache Benchmark (n=10000)
+==============================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+--------------------------------------------------------------------------------------------------------------
+sha256 hashing (10000) 2.884ms 2.875ms 0.034ms 2.815ms 2.950ms 2.921ms
+cache.put (10000) 3.790ms 3.786ms 0.024ms 3.729ms 3.827ms 3.821ms
+cache.get hit (10000) 3.690ms 3.697ms 0.029ms 3.653ms 3.775ms 3.750ms
+cache.get miss (10000) 3.939ms 3.943ms 0.041ms 3.878ms 4.079ms 4.018ms
+cache.get_many (10000) 3.987ms 3.989ms 0.023ms 3.948ms 4.051ms 4.041ms
diff --git a/benchmarks/results/bench_file_hashing_20260315_000043.txt b/benchmarks/results/bench_file_hashing_20260315_000043.txt
new file mode 100644
index 000000000..6346ad2f7
--- /dev/null
+++ b/benchmarks/results/bench_file_hashing_20260315_000043.txt
@@ -0,0 +1,45 @@
+Benchmark: bench_file_hashing.py
+Timestamp: 20260315_000043
+Exit code: 0
+Duration: 4.4s
+Python: 3.12.2 (main, Feb 25 2024, 03:55:42) [Clang 17.0.6 ]
+================================================================================
+
+===================================================================================================================
+File Hashing Benchmark (files=50, avg_size=5KB)
+===================================================================================================================
+Total data: 0.2 MB
+
+Benchmark Median Mean StdDev Min Max P95
+-------------------------------------------------------------------------------------------------------------------
+sha256 8KB buf (50f) 1.006ms 1.016ms 0.043ms 0.977ms 1.186ms 1.146ms
+sha256 64KB buf (50f) 1.075ms 1.070ms 0.016ms 1.036ms 1.106ms 1.090ms
+sha256 mmap (50f) 1.356ms 1.355ms 0.033ms 1.299ms 1.453ms 1.395ms
+md5 (50f) 1.310ms 1.374ms 0.171ms 1.191ms 1.878ms 1.727ms
+blake2b (50f) 1.201ms 1.253ms 0.147ms 1.106ms 1.718ms 1.632ms
+
+===================================================================================================================
+File Hashing Benchmark (files=200, avg_size=10KB)
+===================================================================================================================
+Total data: 2.0 MB
+
+Benchmark Median Mean StdDev Min Max P95
+-------------------------------------------------------------------------------------------------------------------
+sha256 8KB buf (200f) 4.587ms 4.777ms 0.512ms 4.377ms 6.201ms 6.185ms
+sha256 64KB buf (200f) 4.729ms 4.819ms 0.285ms 4.557ms 5.794ms 5.706ms
+sha256 mmap (200f) 5.984ms 8.714ms 11.275ms 5.650ms 63.888ms 29.536ms
+md5 (200f) 6.532ms 6.547ms 0.143ms 6.367ms 6.993ms 6.804ms
+blake2b (200f) 5.217ms 5.289ms 0.272ms 5.068ms 6.416ms 6.003ms
+
+===================================================================================================================
+File Hashing Benchmark (files=500, avg_size=20KB)
+===================================================================================================================
+Total data: 9.8 MB
+
+Benchmark Median Mean StdDev Min Max P95
+-------------------------------------------------------------------------------------------------------------------
+sha256 8KB buf (500f) 13.926ms 14.170ms 0.910ms 13.581ms 18.406ms 15.773ms
+sha256 64KB buf (500f) 14.268ms 14.312ms 0.253ms 13.957ms 15.319ms 14.640ms
+sha256 mmap (500f) 16.699ms 20.110ms 15.978ms 16.299ms 104.163ms 25.618ms
+md5 (500f) 23.512ms 23.670ms 0.567ms 23.157ms 25.836ms 25.075ms
+blake2b (500f) 17.669ms 17.783ms 0.496ms 17.229ms 19.433ms 18.815ms
diff --git a/benchmarks/results/bench_graph_loader_20260315_000043.txt b/benchmarks/results/bench_graph_loader_20260315_000043.txt
new file mode 100644
index 000000000..d9cd28a0b
--- /dev/null
+++ b/benchmarks/results/bench_graph_loader_20260315_000043.txt
@@ -0,0 +1,48 @@
+Benchmark: bench_graph_loader.py
+Timestamp: 20260315_000043
+Exit code: 0
+Duration: 2.9s
+Python: 3.12.2 (main, Feb 25 2024, 03:55:42) [Clang 17.0.6 ]
+================================================================================
+
+==============================================================================================================
+GraphLoader Benchmark (nodes=1000, rels=2000)
+==============================================================================================================
+JSON size: 298.2 KB
+
+Benchmark Median Mean StdDev Min Max P95
+--------------------------------------------------------------------------------------------------------------
+json.loads (1000n) 1.001ms 1.011ms 0.029ms 0.974ms 1.071ms 1.071ms
+GraphLoader.load (1000n) 2.040ms 2.143ms 0.583ms 1.865ms 4.581ms 4.581ms
+find_nodes_by_label (1000n) 0.001ms 0.001ms 0.000ms 0.000ms 0.001ms 0.001ms
+find_node_by_property (1000n) 0.030ms 0.030ms 0.000ms 0.029ms 0.030ms 0.030ms
+get_relationships (1000n) 0.148ms 0.148ms 0.001ms 0.146ms 0.151ms 0.151ms
+summary (1000n) 0.069ms 0.070ms 0.001ms 0.068ms 0.073ms 0.073ms
+
+==============================================================================================================
+GraphLoader Benchmark (nodes=5000, rels=10000)
+==============================================================================================================
+JSON size: 1537.8 KB
+
+Benchmark Median Mean StdDev Min Max P95
+--------------------------------------------------------------------------------------------------------------
+json.loads (5000n) 5.032ms 5.002ms 0.112ms 4.843ms 5.180ms 5.180ms
+GraphLoader.load (5000n) 10.106ms 11.137ms 2.030ms 9.396ms 14.997ms 14.997ms
+find_nodes_by_label (5000n) 0.000ms 0.000ms 0.000ms 0.000ms 0.001ms 0.001ms
+find_node_by_property (5000n) 0.030ms 0.030ms 0.000ms 0.030ms 0.030ms 0.030ms
+get_relationships (5000n) 0.150ms 0.152ms 0.005ms 0.148ms 0.170ms 0.170ms
+summary (5000n) 0.350ms 0.356ms 0.018ms 0.341ms 0.420ms 0.420ms
+
+==============================================================================================================
+GraphLoader Benchmark (nodes=20000, rels=50000)
+==============================================================================================================
+JSON size: 6979.7 KB
+
+Benchmark Median Mean StdDev Min Max P95
+--------------------------------------------------------------------------------------------------------------
+json.loads (20000n) 24.136ms 24.783ms 2.550ms 23.565ms 35.321ms 35.321ms
+GraphLoader.load (20000n) 61.008ms 62.676ms 5.050ms 57.534ms 75.337ms 75.337ms
+find_nodes_by_label (20000n) 0.000ms 0.000ms 0.000ms 0.000ms 0.001ms 0.001ms
+find_node_by_property (20000n) 0.030ms 0.030ms 0.000ms 0.030ms 0.030ms 0.030ms
+get_relationships (20000n) 0.152ms 0.153ms 0.001ms 0.151ms 0.155ms 0.155ms
+summary (20000n) 1.738ms 1.745ms 0.023ms 1.714ms 1.819ms 1.819ms
diff --git a/benchmarks/results/bench_json_serialization_20260315_000043.txt b/benchmarks/results/bench_json_serialization_20260315_000043.txt
new file mode 100644
index 000000000..aab002921
--- /dev/null
+++ b/benchmarks/results/bench_json_serialization_20260315_000043.txt
@@ -0,0 +1,48 @@
+Benchmark: bench_json_serialization.py
+Timestamp: 20260315_000043
+Exit code: 0
+Duration: 18.8s
+Python: 3.12.2 (main, Feb 25 2024, 03:55:42) [Clang 17.0.6 ]
+================================================================================
+
+===================================================================================================================
+JSON Serialization Benchmark (nodes=1000, rels=2000)
+===================================================================================================================
+Compact JSON: 366.8 KB, Indented: 547.7 KB
+
+Benchmark Median Mean StdDev Min Max P95
+-------------------------------------------------------------------------------------------------------------------
+json.dumps compact (1000n) 1.089ms 1.094ms 0.010ms 1.084ms 1.117ms 1.117ms
+json.dumps indented (1000n) 9.612ms 9.703ms 0.220ms 9.560ms 10.479ms 10.479ms
+json.loads compact (1000n) 1.202ms 1.202ms 0.015ms 1.185ms 1.260ms 1.260ms
+json.loads indented (1000n) 1.286ms 1.281ms 0.023ms 1.253ms 1.325ms 1.325ms
+json.dump to file (1000n) 12.239ms 12.241ms 0.071ms 12.145ms 12.398ms 12.398ms
+json.load from file (1000n) 1.345ms 1.350ms 0.036ms 1.309ms 1.429ms 1.429ms
+
+===================================================================================================================
+JSON Serialization Benchmark (nodes=5000, rels=10000)
+===================================================================================================================
+Compact JSON: 1881.4 KB, Indented: 2786.1 KB
+
+Benchmark Median Mean StdDev Min Max P95
+-------------------------------------------------------------------------------------------------------------------
+json.dumps compact (5000n) 5.701ms 5.718ms 0.158ms 5.464ms 6.000ms 6.000ms
+json.dumps indented (5000n) 47.875ms 47.950ms 0.285ms 47.618ms 48.611ms 48.611ms
+json.loads compact (5000n) 6.291ms 6.327ms 0.244ms 5.999ms 6.754ms 6.754ms
+json.loads indented (5000n) 6.686ms 6.666ms 0.263ms 6.346ms 7.152ms 7.152ms
+json.dump to file (5000n) 60.552ms 60.895ms 1.262ms 60.082ms 64.565ms 64.565ms
+json.load from file (5000n) 6.573ms 6.590ms 0.049ms 6.528ms 6.717ms 6.717ms
+
+===================================================================================================================
+JSON Serialization Benchmark (nodes=20000, rels=50000)
+===================================================================================================================
+Compact JSON: 8381.6 KB, Indented: 12363.2 KB
+
+Benchmark Median Mean StdDev Min Max P95
+-------------------------------------------------------------------------------------------------------------------
+json.dumps compact (20000n) 25.446ms 25.483ms 0.156ms 25.314ms 25.797ms 25.797ms
+json.dumps indented (20000n) 215.190ms 215.593ms 1.383ms 214.183ms 219.350ms 219.350ms
+json.loads compact (20000n) 28.713ms 28.731ms 0.480ms 28.049ms 30.253ms 30.253ms
+json.loads indented (20000n) 30.416ms 30.558ms 0.813ms 29.707ms 32.258ms 32.258ms
+json.dump to file (20000n) 271.376ms 271.918ms 3.051ms 266.710ms 278.494ms 278.494ms
+json.load from file (20000n) 32.144ms 33.111ms 3.488ms 31.594ms 47.762ms 47.762ms
diff --git a/benchmarks/results/bench_string_ops_20260315_000043.txt b/benchmarks/results/bench_string_ops_20260315_000043.txt
new file mode 100644
index 000000000..66c1bcd8b
--- /dev/null
+++ b/benchmarks/results/bench_string_ops_20260315_000043.txt
@@ -0,0 +1,51 @@
+Benchmark: bench_string_ops.py
+Timestamp: 20260315_000043
+Exit code: 0
+Duration: 3.2s
+Python: 3.12.2 (main, Feb 25 2024, 03:55:42) [Clang 17.0.6 ]
+================================================================================
+
+==============================================================================================================
+String Operations Benchmark (n=1000)
+==============================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+--------------------------------------------------------------------------------------------------------------
+str.split (1000) 0.079ms 0.079ms 0.001ms 0.077ms 0.083ms 0.082ms
+str.endswith (1000) 0.179ms 0.181ms 0.006ms 0.174ms 0.219ms 0.188ms
+str.startswith (1000) 0.146ms 0.147ms 0.003ms 0.144ms 0.165ms 0.150ms
+str.join (1000) 0.036ms 0.036ms 0.001ms 0.035ms 0.047ms 0.039ms
+str.replace (1000) 0.014ms 0.014ms 0.000ms 0.014ms 0.016ms 0.014ms
+regex split (1000) 0.418ms 0.420ms 0.006ms 0.414ms 0.437ms 0.431ms
+f-string format (1000) 0.029ms 0.029ms 0.000ms 0.029ms 0.032ms 0.029ms
+import_distance (1000) 0.164ms 0.165ms 0.004ms 0.162ms 0.185ms 0.171ms
+
+==============================================================================================================
+String Operations Benchmark (n=5000)
+==============================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+--------------------------------------------------------------------------------------------------------------
+str.split (5000) 0.380ms 0.380ms 0.003ms 0.371ms 0.395ms 0.387ms
+str.endswith (5000) 0.897ms 0.899ms 0.004ms 0.892ms 0.919ms 0.909ms
+str.startswith (5000) 0.722ms 0.723ms 0.003ms 0.715ms 0.733ms 0.728ms
+str.join (5000) 0.185ms 0.187ms 0.005ms 0.184ms 0.234ms 0.191ms
+str.replace (5000) 0.071ms 0.071ms 0.001ms 0.070ms 0.074ms 0.071ms
+regex split (5000) 2.033ms 2.037ms 0.023ms 1.984ms 2.103ms 2.076ms
+f-string format (5000) 0.146ms 0.147ms 0.002ms 0.145ms 0.154ms 0.150ms
+import_distance (5000) 0.781ms 0.773ms 0.014ms 0.752ms 0.797ms 0.790ms
+
+==============================================================================================================
+String Operations Benchmark (n=20000)
+==============================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+--------------------------------------------------------------------------------------------------------------
+str.split (20000) 1.588ms 1.590ms 0.014ms 1.559ms 1.626ms 1.612ms
+str.endswith (20000) 3.582ms 3.619ms 0.147ms 3.497ms 4.883ms 3.803ms
+str.startswith (20000) 2.920ms 2.926ms 0.031ms 2.876ms 3.064ms 3.005ms
+str.join (20000) 0.733ms 0.735ms 0.015ms 0.719ms 0.850ms 0.752ms
+str.replace (20000) 0.287ms 0.288ms 0.009ms 0.282ms 0.374ms 0.293ms
+regex split (20000) 8.051ms 8.047ms 0.068ms 7.924ms 8.195ms 8.174ms
+f-string format (20000) 0.593ms 0.594ms 0.006ms 0.582ms 0.624ms 0.603ms
+import_distance (20000) 3.183ms 3.184ms 0.039ms 3.129ms 3.315ms 3.262ms
diff --git a/benchmarks/results/bench_trie_20260315_000043.txt b/benchmarks/results/bench_trie_20260315_000043.txt
new file mode 100644
index 000000000..10ad3978e
--- /dev/null
+++ b/benchmarks/results/bench_trie_20260315_000043.txt
@@ -0,0 +1,54 @@
+Benchmark: bench_trie.py
+Timestamp: 20260315_000043
+Exit code: 0
+Duration: 9.3s
+Python: 3.12.2 (main, Feb 25 2024, 03:55:42) [Clang 17.0.6 ]
+================================================================================
+
+=========================================================================================================
+FunctionRegistryTrie Benchmark (n=1000)
+=========================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+---------------------------------------------------------------------------------------------------------
+insert (1000) 0.340ms 0.341ms 0.012ms 0.327ms 0.385ms 0.378ms
+lookup (1000) 0.036ms 0.036ms 0.000ms 0.035ms 0.037ms 0.036ms
+find_ending_with (1000) 0.004ms 0.005ms 0.004ms 0.004ms 0.031ms 0.004ms
+find_with_prefix (1000) 0.390ms 0.425ms 0.059ms 0.369ms 0.589ms 0.528ms
+delete 25% (1000) 0.407ms 0.418ms 0.021ms 0.394ms 0.457ms 0.449ms
+
+=========================================================================================================
+FunctionRegistryTrie Benchmark (n=5000)
+=========================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+---------------------------------------------------------------------------------------------------------
+insert (5000) 1.795ms 1.797ms 0.037ms 1.721ms 1.911ms 1.876ms
+lookup (5000) 0.195ms 0.196ms 0.002ms 0.193ms 0.201ms 0.200ms
+find_ending_with (5000) 0.019ms 0.019ms 0.000ms 0.018ms 0.021ms 0.019ms
+find_with_prefix (5000) 2.104ms 2.299ms 1.047ms 2.024ms 9.499ms 2.416ms
+delete 25% (5000) 2.116ms 2.122ms 0.048ms 2.043ms 2.260ms 2.214ms
+
+=========================================================================================================
+FunctionRegistryTrie Benchmark (n=10000)
+=========================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+---------------------------------------------------------------------------------------------------------
+insert (10000) 3.709ms 3.735ms 0.106ms 3.627ms 4.244ms 3.912ms
+lookup (10000) 0.402ms 0.403ms 0.003ms 0.398ms 0.412ms 0.407ms
+find_ending_with (10000) 0.046ms 0.046ms 0.002ms 0.045ms 0.056ms 0.050ms
+find_with_prefix (10000) 4.244ms 4.630ms 1.843ms 3.904ms 13.674ms 5.386ms
+delete 25% (10000) 4.204ms 4.207ms 0.066ms 3.959ms 4.349ms 4.312ms
+
+=========================================================================================================
+FunctionRegistryTrie Benchmark (n=50000)
+=========================================================================================================
+
+Benchmark Median Mean StdDev Min Max P95
+---------------------------------------------------------------------------------------------------------
+insert (50000) 18.036ms 18.128ms 0.306ms 17.831ms 18.972ms 18.820ms
+lookup (50000) 2.058ms 2.061ms 0.013ms 2.036ms 2.091ms 2.085ms
+find_ending_with (50000) 0.420ms 0.426ms 0.014ms 0.412ms 0.477ms 0.458ms
+find_with_prefix (50000) 38.507ms 38.096ms 10.219ms 22.462ms 56.890ms 52.739ms
+delete 25% (50000) 21.744ms 21.830ms 0.410ms 21.277ms 23.496ms 22.524ms
diff --git a/benchmarks/run_all.py b/benchmarks/run_all.py
new file mode 100644
index 000000000..a79c339ab
--- /dev/null
+++ b/benchmarks/run_all.py
@@ -0,0 +1,74 @@
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+BENCHMARKS = [
+ "bench_string_ops.py",
+ "bench_trie.py",
+ "bench_find_ending_with_fix.py",
+ "bench_dropin_replacements.py",
+ "bench_graph_loader.py",
+ "bench_file_hashing.py",
+ "bench_embedding_cache.py",
+ "bench_json_serialization.py",
+ "bench_ast_cache.py",
+ "bench_pathlib_vs_string.py",
+]
+
+
+def main() -> None:
+ bench_dir = Path(__file__).parent
+ results_dir = bench_dir / "results"
+ results_dir.mkdir(exist_ok=True)
+
+ timestamp = time.strftime("%Y%m%d_%H%M%S")
+ overall_start = time.perf_counter()
+
+ print(f"Running {len(BENCHMARKS)} benchmark suites")
+ print(f"Results will be saved to: {results_dir}")
+ print(f"Timestamp: {timestamp}")
+ print("=" * 80)
+
+ for bench_file in BENCHMARKS:
+ bench_path = bench_dir / bench_file
+ if not bench_path.exists():
+ print(f"SKIP: {bench_file} (not found)")
+ continue
+
+ result_file = results_dir / f"{bench_path.stem}_{timestamp}.txt"
+ print(f"\nRunning: {bench_file}")
+
+ start = time.perf_counter()
+ result = subprocess.run(
+ [sys.executable, str(bench_path)],
+ capture_output=True,
+ text=True,
+ timeout=600,
+ )
+ elapsed = time.perf_counter() - start
+
+ output = result.stdout
+ if result.returncode != 0:
+ output += f"\nSTDERR:\n{result.stderr}"
+ print(f" FAILED (exit code {result.returncode}, {elapsed:.1f}s)")
+ else:
+ print(f" OK ({elapsed:.1f}s)")
+
+ with result_file.open("w") as f:
+ f.write(f"Benchmark: {bench_file}\n")
+ f.write(f"Timestamp: {timestamp}\n")
+ f.write(f"Exit code: {result.returncode}\n")
+ f.write(f"Duration: {elapsed:.1f}s\n")
+ f.write(f"Python: {sys.version}\n")
+ f.write("=" * 80 + "\n")
+ f.write(output)
+
+ total = time.perf_counter() - overall_start
+ print(f"\n{'='*80}")
+ print(f"All benchmarks completed in {total:.1f}s")
+ print(f"Results saved in: {results_dir}")
+
+
+if __name__ == "__main__":
+ main()
diff --git a/build_binary.py b/build_binary.py
index b82c48c6e..fd1884a0c 100644
--- a/build_binary.py
+++ b/build_binary.py
@@ -70,6 +70,9 @@ def build_binary() -> bool:
for pkg in cs.PYINSTALLER_PACKAGES:
cmd.extend(_build_package_args(pkg))
+ for mod in cs.PYINSTALLER_EXCLUDED_MODULES:
+ cmd.extend([cs.PYINSTALLER_ARG_EXCLUDE_MODULE, mod])
+
cmd.append(cs.PYINSTALLER_ENTRY_POINT)
logger.info(logs.BUILD_BINARY.format(name=binary_name))
diff --git a/cgr/__init__.py b/cgr/__init__.py
new file mode 100644
index 000000000..3d76ac771
--- /dev/null
+++ b/cgr/__init__.py
@@ -0,0 +1,14 @@
+from codebase_rag.config import settings
+from codebase_rag.embedder import embed_code
+from codebase_rag.graph_loader import GraphLoader, load_graph
+from codebase_rag.services.graph_service import MemgraphIngestor
+from codebase_rag.services.llm import CypherGenerator
+
+__all__ = [
+ "CypherGenerator",
+ "GraphLoader",
+ "MemgraphIngestor",
+ "embed_code",
+ "load_graph",
+ "settings",
+]
diff --git a/codebase_rag/cgr_state.py b/codebase_rag/cgr_state.py
new file mode 100644
index 000000000..703672a64
--- /dev/null
+++ b/codebase_rag/cgr_state.py
@@ -0,0 +1,57 @@
+from __future__ import annotations
+
+import json
+from datetime import UTC, datetime
+from pathlib import Path
+from typing import TypedDict
+
+from loguru import logger
+
+from .config import settings
+
+STATE_FILENAME = "state.json"
+
+
+class _StateShape(TypedDict, total=False):
+ last_sync: dict[str, str]
+
+
+def state_path(home: Path | None = None) -> Path:
+ base = (home or settings.CGR_HOME).expanduser()
+ return base / STATE_FILENAME
+
+
+def _load(path: Path) -> _StateShape:
+ if not path.exists():
+ return _StateShape()
+ try:
+ with path.open(encoding="utf-8") as f:
+ data = json.load(f)
+ if isinstance(data, dict):
+ return _StateShape(last_sync=data.get("last_sync", {}))
+ except (OSError, json.JSONDecodeError) as e:
+ logger.warning(f"Failed to load cgr state from {path}: {e}")
+ return _StateShape()
+
+
+def _save(path: Path, data: _StateShape) -> None:
+ try:
+ path.parent.mkdir(parents=True, exist_ok=True)
+ with path.open("w", encoding="utf-8") as f:
+ json.dump(data, f, indent=2)
+ except OSError as e:
+ logger.warning(f"Failed to save cgr state to {path}: {e}")
+
+
+def record_sync(project_name: str, home: Path | None = None) -> None:
+ path = state_path(home)
+ state = _load(path)
+ last_sync = state.get("last_sync", {})
+ last_sync[project_name] = datetime.now(UTC).isoformat()
+ state["last_sync"] = last_sync
+ _save(path, state)
+
+
+def read_sync_timestamps(home: Path | None = None) -> dict[str, str]:
+ state = _load(state_path(home))
+ return dict(state.get("last_sync", {}))
diff --git a/codebase_rag/cli.py b/codebase_rag/cli.py
index 87f9a5379..07b72ad88 100644
--- a/codebase_rag/cli.py
+++ b/codebase_rag/cli.py
@@ -1,39 +1,69 @@
import asyncio
+import json
+import time
+from collections.abc import Callable
+from functools import partial
+from importlib.metadata import version as get_version
from pathlib import Path
import typer
from loguru import logger
+from rich.console import Console
from rich.panel import Panel
from rich.table import Table
+from . import cgr_state
from . import cli_help as ch
from . import constants as cs
from . import logs as ls
from .config import load_cgrignore_patterns, settings
from .graph_updater import GraphUpdater
from .main import (
+ _create_configuration_table,
app_context,
connect_memgraph,
export_graph_to_file,
main_async,
main_optimize_async,
+ main_single_query,
prompt_for_unignored_directories,
style,
update_model_settings,
)
from .parser_loader import load_parsers
+from .services.graph_service import MemgraphIngestor
from .services.protobuf_service import ProtobufFileIngestor
+from .stack import StackManager
+from .stack.cli import cli as daemon_cli
+from .stack.constants import StackState
+from .stack.manager import StackError
from .tools.health_checker import HealthChecker
from .tools.language import cli as language_cli
+from .types_defs import DeadCodeRow, PropertyValue, ResultRow
+from .utils.path_utils import derive_project_name, resolve_repo_path
+from .vector_store import delete_project_embeddings
+from .workspaces import WorkspaceConfig, WorkspaceError, load_workspace
+from .workspaces.cli import cli as workspace_cli
app = typer.Typer(
- name="code-graph-rag",
+ name=cs.PACKAGE_NAME,
help=ch.APP_DESCRIPTION,
no_args_is_help=True,
add_completion=False,
)
+def _version_callback(value: bool) -> None:
+ if value:
+ app_context.console.print(
+ cs.CLI_MSG_VERSION.format(
+ package=cs.PACKAGE_NAME, version=get_version(cs.PACKAGE_NAME)
+ ),
+ highlight=False,
+ )
+ raise typer.Exit()
+
+
def validate_models_early() -> None:
try:
orchestrator_config = settings.active_orchestrator_config
@@ -58,6 +88,14 @@ def _update_and_validate_models(orchestrator: str | None, cypher: str | None) ->
@app.callback()
def _global_options(
+ version: bool | None = typer.Option(
+ None,
+ "--version",
+ "-v",
+ help=ch.HELP_VERSION,
+ callback=_version_callback,
+ is_eager=True,
+ ),
quiet: bool = typer.Option(
False,
"--quiet",
@@ -77,6 +115,184 @@ def _info(msg: str) -> None:
app_context.console.print(msg)
+def _load_workspace_or_exit(workspace: str | None) -> WorkspaceConfig | None:
+ if workspace is None:
+ return None
+ try:
+ return load_workspace(workspace)
+ except WorkspaceError as e:
+ app_context.console.print(style(str(e), cs.Color.RED))
+ raise typer.Exit(1) from e
+
+
+def _sync_workspace(
+ config: WorkspaceConfig,
+ batch_size: int,
+ exclude: list[str] | None,
+) -> None:
+ total = len(config.repos)
+ if total == 0:
+ _info(
+ style(cs.CLI_MSG_WORKSPACE_EMPTY.format(name=config.name), cs.Color.YELLOW)
+ )
+ return
+ _info(
+ style(
+ cs.CLI_MSG_WORKSPACE_SYNCING.format(name=config.name, count=total),
+ cs.Color.CYAN,
+ )
+ )
+ for idx, repo in enumerate(config.repos, start=1):
+ repo_path = repo.repo_path()
+ _info(
+ style(
+ cs.CLI_MSG_WORKSPACE_SYNC_REPO.format(
+ idx=idx,
+ total=total,
+ path=repo_path,
+ project_name=repo.project_name,
+ ),
+ cs.Color.CYAN,
+ )
+ )
+ _run_graph_sync(
+ repo=repo_path,
+ project_name=repo.project_name,
+ batch_size=batch_size,
+ exclude=exclude,
+ interactive_setup=False,
+ )
+
+
+def _resolve_active_projects(projects: str | None, default_project: str) -> list[str]:
+ if projects:
+ parsed = [p.strip() for p in projects.split(",") if p.strip()]
+ if parsed:
+ return parsed
+ return [default_project]
+
+
+def _maybe_start_stack() -> None:
+ mgr = StackManager()
+ if mgr.status().state == StackState.RUNNING:
+ return
+ try:
+ mgr.ensure_running()
+ except StackError as e:
+ app_context.console.print(style(str(e), cs.Color.RED))
+ raise typer.Exit(1) from e
+
+
+def _run_graph_sync(
+ repo: Path,
+ project_name: str,
+ batch_size: int,
+ exclude: list[str] | None,
+ interactive_setup: bool,
+ clean: bool = False,
+ output: str | None = None,
+) -> None:
+ cgrignore = load_cgrignore_patterns(repo)
+ cli_excludes = frozenset(exclude) if exclude else frozenset()
+ exclude_paths = cli_excludes | cgrignore.exclude or None
+ unignore_paths: frozenset[str] | None
+ if interactive_setup:
+ unignore_paths = prompt_for_unignored_directories(repo, exclude)
+ else:
+ unignore_paths = cgrignore.unignore or None
+
+ elapsed = time.monotonic()
+ with connect_memgraph(batch_size) as ingestor:
+ if clean:
+ _info(style(cs.CLI_MSG_CLEANING_DB, cs.Color.YELLOW))
+ ingestor.clean_database()
+ _delete_hash_cache(repo)
+
+ ingestor.ensure_constraints()
+
+ parsers, queries = load_parsers()
+
+ updater = GraphUpdater(
+ ingestor=ingestor,
+ repo_path=repo,
+ parsers=parsers,
+ queries=queries,
+ unignore_paths=unignore_paths,
+ exclude_paths=exclude_paths,
+ project_name=project_name,
+ )
+ updater.run()
+ cgr_state.record_sync(project_name)
+
+ if output:
+ _info(style(cs.CLI_MSG_EXPORTING_TO.format(path=output), cs.Color.CYAN))
+ if not export_graph_to_file(ingestor, output):
+ raise typer.Exit(1)
+ elapsed = time.monotonic() - elapsed
+ if updater.skipped_because_in_sync:
+ app_context.console.print(
+ style(
+ cs.CLI_MSG_SYNC_SKIPPED.format(project=project_name, elapsed=elapsed),
+ cs.Color.CYAN,
+ cs.StyleModifier.DIM,
+ )
+ )
+ else:
+ app_context.console.print(
+ style(
+ cs.CLI_MSG_SYNC_DONE.format(project=project_name, elapsed=elapsed),
+ cs.Color.CYAN,
+ cs.StyleModifier.NONE,
+ )
+ )
+
+
+def _delete_hash_cache(repo_path: Path) -> None:
+ cache_path = repo_path / cs.HASH_CACHE_FILENAME
+ if cache_path.exists():
+ _info(
+ style(
+ cs.CLI_MSG_CLEANING_HASH_CACHE.format(path=cache_path),
+ cs.Color.YELLOW,
+ )
+ )
+ cache_path.unlink(missing_ok=True)
+ dir_mtimes_path = repo_path / cs.DIR_MTIMES_FILENAME
+ dir_mtimes_path.unlink(missing_ok=True)
+
+
+def _resolve_and_validate_repo(repo_path: str | None) -> Path:
+ resolved = resolve_repo_path(repo_path, settings.TARGET_REPO_PATH)
+ if not resolved.exists():
+ app_context.console.print(
+ style(cs.CLI_ERR_PATH_NOT_EXISTS.format(path=resolved), cs.Color.RED)
+ )
+ raise typer.Exit(1)
+ if not resolved.is_dir():
+ app_context.console.print(
+ style(cs.CLI_ERR_PATH_NOT_DIR.format(path=resolved), cs.Color.RED)
+ )
+ raise typer.Exit(1)
+ if not (resolved / cs.GIT_DIR_NAME).exists():
+ app_context.console.print(
+ style(cs.CLI_WARN_NOT_GIT_REPO.format(path=resolved), cs.Color.YELLOW)
+ )
+ return resolved
+
+
+def _cleanup_project_embeddings(ingestor: MemgraphIngestor, project_name: str) -> None:
+ rows = ingestor.fetch_all(
+ cs.CYPHER_QUERY_PROJECT_NODE_IDS,
+ {cs.KEY_PROJECT_NAME: project_name},
+ )
+ node_ids: list[int] = []
+ for row in rows:
+ node_id = row.get(cs.KEY_NODE_ID)
+ if isinstance(node_id, int):
+ node_ids.append(node_id)
+ delete_project_embeddings(project_name, node_ids)
+
+
@app.command(help=ch.CMD_START)
def start(
repo_path: str | None = typer.Option(
@@ -113,12 +329,22 @@ def start(
"--no-confirm",
help=ch.HELP_NO_CONFIRM,
),
+ no_instructions: bool = typer.Option(
+ False,
+ "--no-instructions",
+ help=ch.HELP_NO_INSTRUCTIONS,
+ ),
batch_size: int | None = typer.Option(
None,
"--batch-size",
min=1,
help=ch.HELP_BATCH_SIZE,
),
+ project_name: str | None = typer.Option(
+ None,
+ "--project-name",
+ help=ch.HELP_PROJECT_NAME,
+ ),
exclude: list[str] | None = typer.Option(
None,
"--exclude",
@@ -129,10 +355,50 @@ def start(
"--interactive-setup",
help=ch.HELP_INTERACTIVE_SETUP,
),
+ ask_agent: str | None = typer.Option(
+ None,
+ "-a",
+ "--ask-agent",
+ help=ch.HELP_ASK_AGENT,
+ ),
+ output_format: cs.QueryFormat = typer.Option(
+ cs.QueryFormat.TABLE,
+ "--output-format",
+ help=ch.HELP_QUERY_OUTPUT_FORMAT,
+ ),
+ no_start_stack: bool = typer.Option(
+ False,
+ "--no-start-stack",
+ help=ch.HELP_NO_START_STACK,
+ ),
+ no_sync: bool = typer.Option(
+ False,
+ "--no-sync",
+ help=ch.HELP_NO_SYNC,
+ ),
+ projects: str | None = typer.Option(
+ None,
+ "--projects",
+ help=ch.HELP_PROJECTS,
+ ),
+ workspace: str | None = typer.Option(
+ None,
+ "--workspace",
+ help=ch.HELP_WORKSPACE,
+ ),
) -> None:
app_context.session.confirm_edits = not no_confirm
+ app_context.session.load_cgr_instructions = not no_instructions
+
+ if output_format == cs.QueryFormat.JSON and not ask_agent:
+ app_context.console.print(
+ style(cs.CLI_ERR_JSON_REQUIRES_ASK_AGENT, cs.Color.RED)
+ )
+ raise typer.Exit(1)
- target_repo_path = repo_path or settings.TARGET_REPO_PATH
+ resolved_repo = _resolve_and_validate_repo(repo_path)
+ target_repo_path = str(resolved_repo)
+ resolved_project_name = project_name or derive_project_name(resolved_repo)
if output and not update_graph:
app_context.console.print(
@@ -140,54 +406,95 @@ def start(
)
raise typer.Exit(1)
- _update_and_validate_models(orchestrator, cypher)
+ if not no_start_stack:
+ _maybe_start_stack()
effective_batch_size = settings.resolve_batch_size(batch_size)
+ if clean and not update_graph:
+ repo_to_clean = Path(target_repo_path)
+ with connect_memgraph(effective_batch_size) as ingestor:
+ _info(style(cs.CLI_MSG_CLEANING_DB, cs.Color.YELLOW))
+ ingestor.clean_database()
+
+ _delete_hash_cache(repo_to_clean)
+ _info(style(cs.CLI_MSG_CLEAN_DONE, cs.Color.GREEN))
+ return
+
+ _update_and_validate_models(orchestrator, cypher)
+
+ if not ask_agent and not update_graph:
+ app_context.console.print(_create_configuration_table(target_repo_path))
+
if update_graph:
- repo_to_update = Path(target_repo_path)
_info(
- style(cs.CLI_MSG_UPDATING_GRAPH.format(path=repo_to_update), cs.Color.GREEN)
+ style(cs.CLI_MSG_UPDATING_GRAPH.format(path=resolved_repo), cs.Color.GREEN)
)
-
- cgrignore = load_cgrignore_patterns(repo_to_update)
- cli_excludes = frozenset(exclude) if exclude else frozenset()
- exclude_paths = cli_excludes | cgrignore.exclude or None
- unignore_paths: frozenset[str] | None = None
- if interactive_setup:
- unignore_paths = prompt_for_unignored_directories(repo_to_update, exclude)
- else:
+ if not interactive_setup:
_info(style(cs.CLI_MSG_AUTO_EXCLUDE, cs.Color.YELLOW))
- unignore_paths = cgrignore.unignore or None
+ _run_graph_sync(
+ repo=resolved_repo,
+ project_name=resolved_project_name,
+ batch_size=effective_batch_size,
+ exclude=exclude,
+ interactive_setup=interactive_setup,
+ clean=clean,
+ output=output,
+ )
+ _info(style(cs.CLI_MSG_GRAPH_UPDATED, cs.Color.GREEN))
+ return
- with connect_memgraph(effective_batch_size) as ingestor:
- if clean:
- _info(style(cs.CLI_MSG_CLEANING_DB, cs.Color.YELLOW))
- ingestor.clean_database()
- ingestor.ensure_constraints()
-
- parsers, queries = load_parsers()
-
- updater = GraphUpdater(
- ingestor,
- repo_to_update,
- parsers,
- queries,
- unignore_paths,
- exclude_paths,
- )
- updater.run()
+ workspace_config = _load_workspace_or_exit(workspace)
- if output:
- _info(style(cs.CLI_MSG_EXPORTING_TO.format(path=output), cs.Color.CYAN))
- if not export_graph_to_file(ingestor, output):
- raise typer.Exit(1)
+ sync_task: Callable[[], None] | None = None
+ sync_message = cs.MSG_SYNCING_KNOWLEDGE_GRAPH
+ if not no_sync:
+ if workspace_config is not None:
+ sync_task = partial(
+ _sync_workspace, workspace_config, effective_batch_size, exclude
+ )
+ sync_message = cs.MSG_SYNCING_WORKSPACE.format(
+ name=workspace_config.name, count=len(workspace_config.repos)
+ )
+ else:
+ sync_task = partial(
+ _run_graph_sync,
+ repo=resolved_repo,
+ project_name=resolved_project_name,
+ batch_size=effective_batch_size,
+ exclude=exclude,
+ interactive_setup=interactive_setup,
+ )
- _info(style(cs.CLI_MSG_GRAPH_UPDATED, cs.Color.GREEN))
- return
+ if workspace_config is not None:
+ active_projects = workspace_config.project_names()
+ if projects:
+ active_projects = _resolve_active_projects(projects, active_projects[0])
+ else:
+ active_projects = _resolve_active_projects(projects, resolved_project_name)
try:
- asyncio.run(main_async(target_repo_path, effective_batch_size))
+ if ask_agent:
+ if sync_task is not None:
+ sync_task()
+ main_single_query(
+ target_repo_path,
+ effective_batch_size,
+ ask_agent,
+ active_projects=active_projects,
+ output_format=output_format,
+ )
+ else:
+ asyncio.run(
+ main_async(
+ target_repo_path,
+ effective_batch_size,
+ active_projects=active_projects,
+ show_config_table=False,
+ pre_chat_sync=sync_task,
+ pre_chat_sync_message=sync_message,
+ )
+ )
except KeyboardInterrupt:
app_context.console.print(style(cs.CLI_MSG_APP_TERMINATED, cs.Color.RED))
except ValueError as e:
@@ -223,8 +530,7 @@ def index(
help=ch.HELP_INTERACTIVE_SETUP,
),
) -> None:
- target_repo_path = repo_path or settings.TARGET_REPO_PATH
- repo_to_index = Path(target_repo_path)
+ repo_to_index = _resolve_and_validate_repo(repo_path)
_info(style(cs.CLI_MSG_INDEXING_AT.format(path=repo_to_index), cs.Color.GREEN))
_info(style(cs.CLI_MSG_OUTPUT_TO.format(path=output_proto_dir), cs.Color.CYAN))
@@ -245,7 +551,12 @@ def index(
)
parsers, queries = load_parsers()
updater = GraphUpdater(
- ingestor, repo_to_index, parsers, queries, unignore_paths, exclude_paths
+ ingestor=ingestor,
+ repo_path=repo_to_index,
+ parsers=parsers,
+ queries=queries,
+ unignore_paths=unignore_paths,
+ exclude_paths=exclude_paths,
)
updater.run()
@@ -324,6 +635,11 @@ def optimize(
"--no-confirm",
help=ch.HELP_NO_CONFIRM,
),
+ no_instructions: bool = typer.Option(
+ False,
+ "--no-instructions",
+ help=ch.HELP_NO_INSTRUCTIONS,
+ ),
batch_size: int | None = typer.Option(
None,
"--batch-size",
@@ -332,8 +648,9 @@ def optimize(
),
) -> None:
app_context.session.confirm_edits = not no_confirm
+ app_context.session.load_cgr_instructions = not no_instructions
- target_repo_path = repo_path or settings.TARGET_REPO_PATH
+ target_repo_path = str(_resolve_and_validate_repo(repo_path))
_update_and_validate_models(orchestrator, cypher)
@@ -357,11 +674,24 @@ def optimize(
@app.command(name=ch.CLICommandName.MCP_SERVER, help=ch.CMD_MCP_SERVER)
-def mcp_server() -> None:
+def mcp_server(
+ transport: cs.MCPTransport = typer.Option(
+ cs.MCPTransport.STDIO, help=ch.HELP_MCP_TRANSPORT
+ ),
+ host: str = typer.Option(None, help=ch.HELP_MCP_HTTP_HOST),
+ port: int = typer.Option(None, help=ch.HELP_MCP_HTTP_PORT),
+) -> None:
try:
- from codebase_rag.mcp import main as mcp_main
+ if transport == cs.MCPTransport.HTTP:
+ from codebase_rag.mcp import serve_http
+
+ resolved_host = host or settings.MCP_HTTP_HOST
+ resolved_port = port or settings.MCP_HTTP_PORT
+ asyncio.run(serve_http(host=resolved_host, port=resolved_port))
+ else:
+ from codebase_rag.mcp import serve_stdio
- asyncio.run(mcp_main())
+ asyncio.run(serve_stdio())
except KeyboardInterrupt:
app_context.console.print(style(cs.CLI_MSG_APP_TERMINATED, cs.Color.RED))
except ValueError as e:
@@ -369,7 +699,6 @@ def mcp_server() -> None:
style(cs.CLI_ERR_CONFIG.format(error=e), cs.Color.RED)
)
_info(style(cs.CLI_MSG_HINT_TARGET_REPO, cs.Color.YELLOW))
-
except Exception as e:
app_context.console.print(
style(cs.CLI_ERR_MCP_SERVER.format(error=e), cs.Color.RED)
@@ -417,6 +746,53 @@ def language_command(ctx: typer.Context) -> None:
language_cli(ctx.args, standalone_mode=False)
+@app.command(
+ name=ch.CLICommandName.DAEMON,
+ help=ch.CMD_DAEMON,
+ context_settings={"allow_extra_args": True, "allow_interspersed_args": False},
+)
+def daemon_command(ctx: typer.Context) -> None:
+ daemon_cli(ctx.args, standalone_mode=False)
+
+
+@app.command(
+ name=ch.CLICommandName.WORKSPACE,
+ help=ch.CMD_WORKSPACE,
+ context_settings={"allow_extra_args": True, "allow_interspersed_args": False},
+)
+def workspace_command(ctx: typer.Context) -> None:
+ workspace_cli(ctx.args, standalone_mode=False)
+
+
+@app.command(name=ch.CLICommandName.STOP, help=ch.CMD_STOP)
+def stop_command() -> None:
+ mgr = StackManager()
+ try:
+ mgr.down()
+ except StackError as e:
+ app_context.console.print(style(str(e), cs.Color.RED))
+ raise typer.Exit(1) from e
+ _info(style("stack stopped", cs.Color.GREEN))
+
+
+@app.command(name=ch.CLICommandName.STATUS, help=ch.CMD_STATUS)
+def status_command() -> None:
+ status = StackManager().status()
+ app_context.console.print(
+ f"stack: {status.state.value} "
+ f"(memgraph={status.memgraph_endpoint} reachable={status.memgraph_reachable}, "
+ f"qdrant={status.qdrant_endpoint} reachable={status.qdrant_reachable})"
+ )
+ app_context.console.print(f"compose: {status.compose_file}")
+ timestamps = cgr_state.read_sync_timestamps()
+ if not timestamps:
+ app_context.console.print("syncs: (no projects synced via cgr yet)")
+ return
+ app_context.console.print("syncs:")
+ for project, ts in sorted(timestamps.items()):
+ app_context.console.print(f" - {project}: last sync {ts}")
+
+
@app.command(name=ch.CLICommandName.DOCTOR, help=ch.CMD_DOCTOR)
def doctor() -> None:
checker = HealthChecker()
@@ -465,5 +841,324 @@ def doctor() -> None:
raise typer.Exit(1)
+def _build_stats_table(
+ title: str,
+ col_label: str,
+ rows: list[ResultRow],
+ get_label: Callable[[ResultRow], str],
+ total_label: str,
+) -> Table:
+ table = Table(
+ title=style(title, cs.Color.GREEN),
+ show_header=True,
+ header_style=f"{cs.StyleModifier.BOLD} {cs.Color.MAGENTA}",
+ )
+ table.add_column(col_label, style=cs.Color.CYAN)
+ table.add_column(cs.CLI_STATS_COL_COUNT, style=cs.Color.YELLOW, justify="right")
+ total = 0
+ for row in rows:
+ raw_count = row.get("count", 0)
+ count = int(raw_count) if isinstance(raw_count, int | float) else 0
+ total += count
+ table.add_row(get_label(row), f"{count:,}")
+ table.add_section()
+ table.add_row(
+ style(total_label, cs.Color.GREEN),
+ style(f"{total:,}", cs.Color.GREEN),
+ )
+ return table
+
+
+@app.command(name=ch.CLICommandName.STATS, help=ch.CMD_STATS)
+def stats() -> None:
+ from .cypher_queries import (
+ CYPHER_STATS_NODE_COUNTS,
+ CYPHER_STATS_RELATIONSHIP_COUNTS,
+ )
+
+ app_context.console.print(style(cs.CLI_MSG_CONNECTING_STATS, cs.Color.CYAN))
+
+ try:
+ with connect_memgraph(batch_size=1) as ingestor:
+ node_results = ingestor.fetch_all(CYPHER_STATS_NODE_COUNTS)
+ rel_results = ingestor.fetch_all(CYPHER_STATS_RELATIONSHIP_COUNTS)
+
+ app_context.console.print(
+ _build_stats_table(
+ cs.CLI_STATS_NODE_TITLE,
+ cs.CLI_STATS_COL_NODE_TYPE,
+ node_results,
+ lambda r: ":".join(r.get("labels", [])) or cs.CLI_STATS_UNKNOWN,
+ cs.CLI_STATS_TOTAL_NODES,
+ )
+ )
+ app_context.console.print()
+ app_context.console.print(
+ _build_stats_table(
+ cs.CLI_STATS_REL_TITLE,
+ cs.CLI_STATS_COL_REL_TYPE,
+ rel_results,
+ lambda r: str(r.get("type", cs.CLI_STATS_UNKNOWN)),
+ cs.CLI_STATS_TOTAL_RELS,
+ )
+ )
+
+ except Exception as e:
+ app_context.console.print(
+ style(cs.CLI_ERR_STATS_FAILED.format(error=e), cs.Color.RED)
+ )
+ logger.exception(ls.STATS_ERROR.format(error=e))
+ raise typer.Exit(1) from e
+
+
+def _resolve_dead_code_project(
+ project_name: str | None, projects: list[str]
+) -> str | None:
+ if project_name:
+ return project_name.strip()
+ if len(projects) == 1:
+ return projects[0]
+ return None
+
+
+def _dead_code_params(
+ project_name: str,
+ entry_points: list[str],
+ decorator_roots: list[str],
+) -> dict[str, PropertyValue]:
+ root_decorators = sorted(
+ {d.lower() for d in cs.DEFAULT_ROOT_DECORATORS}
+ | {d.lower() for d in decorator_roots}
+ )
+ # (H) test_patterns is always passed: with tests included it makes test
+ # (H) functions roots; with tests excluded it filters test modules out of the
+ # (H) module-load root clause so test-only code is not kept alive.
+ return {
+ "project_prefix": f"{project_name}{cs.SEPARATOR_DOT}",
+ "root_decorators": root_decorators,
+ "entry_points": list(entry_points),
+ "test_patterns": list(cs.TEST_PATH_PATTERNS),
+ }
+
+
+def _to_dead_code_row(row: ResultRow) -> DeadCodeRow:
+ start = row.get(cs.KEY_START_LINE, 0)
+ end = row.get(cs.KEY_END_LINE, 0)
+ return DeadCodeRow(
+ label=str(row.get(cs.KEY_LABEL, "")),
+ name=str(row.get(cs.KEY_NAME, "")),
+ qualified_name=str(row.get(cs.KEY_QUALIFIED_NAME, "")),
+ start_line=int(start) if isinstance(start, int | float) else 0,
+ end_line=int(end) if isinstance(end, int | float) else 0,
+ )
+
+
+def _build_dead_code_table(candidates: list[DeadCodeRow], project_name: str) -> Table:
+ table = Table(
+ title=style(
+ cs.CLI_DEADCODE_TABLE_TITLE.format(project_name=project_name),
+ cs.Color.GREEN,
+ ),
+ show_header=True,
+ header_style=f"{cs.StyleModifier.BOLD} {cs.Color.MAGENTA}",
+ )
+ table.add_column(cs.CLI_DEADCODE_COL_KIND, style=cs.Color.MAGENTA)
+ table.add_column(cs.CLI_DEADCODE_COL_QUALIFIED_NAME, style=cs.Color.CYAN)
+ table.add_column(cs.CLI_DEADCODE_COL_LINES, style=cs.Color.YELLOW, justify="right")
+ for row in candidates:
+ table.add_row(
+ row["label"],
+ row["qualified_name"],
+ cs.CLI_DEADCODE_LINE_RANGE.format(
+ start=row["start_line"], end=row["end_line"]
+ ),
+ )
+ return table
+
+
+def _emit_dead_code(
+ candidates: list[DeadCodeRow],
+ output_format: cs.DeadCodeFormat,
+ output: Path | None,
+ project_name: str,
+) -> None:
+ if output_format == cs.DeadCodeFormat.JSON:
+ payload = json.dumps(candidates, indent=2)
+ if output is not None:
+ output.write_text(payload, encoding=cs.ENCODING_UTF8)
+ app_context.console.print(
+ style(
+ cs.CLI_DEADCODE_WRITTEN.format(count=len(candidates), path=output),
+ cs.Color.GREEN,
+ )
+ )
+ return
+ typer.echo(payload)
+ return
+
+ table = _build_dead_code_table(candidates, project_name)
+ if output is not None:
+ with output.open("w", encoding=cs.ENCODING_UTF8) as fh:
+ Console(file=fh).print(table)
+ app_context.console.print(
+ style(
+ cs.CLI_DEADCODE_WRITTEN.format(count=len(candidates), path=output),
+ cs.Color.GREEN,
+ )
+ )
+ return
+
+ if not candidates:
+ app_context.console.print(style(cs.CLI_DEADCODE_NONE, cs.Color.GREEN))
+ return
+ app_context.console.print(table)
+ app_context.console.print(
+ style(cs.CLI_DEADCODE_SUMMARY.format(count=len(candidates)), cs.Color.GREEN)
+ )
+
+
+@app.command(name=ch.CLICommandName.DEAD_CODE, help=ch.CMD_DEAD_CODE)
+def dead_code(
+ project_name: str | None = typer.Option(
+ None, "--project-name", "-n", help=ch.HELP_DEADCODE_PROJECT_NAME
+ ),
+ entry_point: list[str] = typer.Option(
+ [], "--entry-point", "-e", help=ch.HELP_DEADCODE_ENTRY_POINT
+ ),
+ decorator_root: list[str] = typer.Option(
+ [], "--decorator-root", help=ch.HELP_DEADCODE_DECORATOR_ROOT
+ ),
+ include_tests: bool = typer.Option(
+ True,
+ "--include-tests/--no-include-tests",
+ help=ch.HELP_DEADCODE_INCLUDE_TESTS,
+ ),
+ include_classes: bool = typer.Option(
+ False,
+ "--classes/--no-classes",
+ help=ch.HELP_DEADCODE_CLASSES,
+ ),
+ output_format: cs.DeadCodeFormat = typer.Option(
+ cs.DeadCodeFormat.TABLE, "--format", help=ch.HELP_DEADCODE_FORMAT
+ ),
+ output: Path | None = typer.Option(
+ None, "--output", "-o", help=ch.HELP_DEADCODE_OUTPUT
+ ),
+ fail_on_found: bool = typer.Option(
+ False, "--fail-on-found", help=ch.HELP_DEADCODE_FAIL_ON_FOUND
+ ),
+) -> None:
+ from .cypher_queries import build_dead_code_query
+
+ show_progress = output_format == cs.DeadCodeFormat.TABLE and output is None
+ if show_progress:
+ app_context.console.print(style(cs.CLI_DEADCODE_CONNECTING, cs.Color.CYAN))
+
+ projects: list[str] = []
+ resolved: str | None = None
+ rows: list[ResultRow] = []
+ try:
+ with connect_memgraph(batch_size=1) as ingestor:
+ projects = ingestor.list_projects()
+ resolved = _resolve_dead_code_project(project_name, projects)
+ if resolved is not None:
+ logger.info(ls.DEADCODE_SCANNING.format(project_name=resolved))
+ rows = ingestor.fetch_all(
+ build_dead_code_query(include_tests, include_classes),
+ _dead_code_params(resolved, entry_point, decorator_root),
+ )
+ except Exception as e:
+ app_context.console.print(
+ style(cs.CLI_ERR_DEADCODE_FAILED.format(error=e), cs.Color.RED)
+ )
+ logger.exception(ls.DEADCODE_ERROR.format(error=e))
+ raise typer.Exit(1) from e
+
+ if resolved is None:
+ message = (
+ cs.CLI_ERR_DEADCODE_NO_PROJECTS
+ if not projects
+ else cs.CLI_ERR_DEADCODE_AMBIGUOUS_PROJECT.format(projects=projects)
+ )
+ app_context.console.print(style(message, cs.Color.RED))
+ raise typer.Exit(1)
+
+ candidates = [_to_dead_code_row(row) for row in rows]
+ _emit_dead_code(candidates, output_format, output, resolved)
+
+ if fail_on_found and candidates:
+ raise typer.Exit(1)
+
+
+@app.command(name=ch.CLICommandName.DELETE_PROJECT, help=ch.CMD_DELETE_PROJECT)
+def delete_project(
+ name: str = typer.Option(
+ ...,
+ "--name",
+ "-n",
+ help=ch.HELP_DELETE_PROJECT_NAME,
+ ),
+ repo_path: str | None = typer.Option(
+ None,
+ "--repo-path",
+ help=ch.HELP_DELETE_PROJECT_REPO_PATH,
+ ),
+) -> None:
+ project_name = name.strip()
+ if not project_name:
+ app_context.console.print(style(cs.CLI_ERR_PROJECT_NAME_REQUIRED, cs.Color.RED))
+ raise typer.Exit(1)
+
+ effective_batch_size = settings.resolve_batch_size(None)
+
+ try:
+ with connect_memgraph(effective_batch_size) as ingestor:
+ projects = ingestor.list_projects()
+ if project_name not in projects:
+ app_context.console.print(
+ style(
+ cs.CLI_ERR_PROJECT_NOT_FOUND.format(
+ project_name=project_name, projects=projects
+ ),
+ cs.Color.RED,
+ )
+ )
+ raise typer.Exit(1)
+
+ _info(
+ style(
+ cs.CLI_MSG_DELETING_PROJECT.format(project_name=project_name),
+ cs.Color.YELLOW,
+ )
+ )
+ _cleanup_project_embeddings(ingestor, project_name)
+ ingestor.delete_project(project_name)
+ except typer.Exit:
+ raise
+ except Exception as e:
+ app_context.console.print(
+ style(
+ cs.CLI_ERR_DELETE_PROJECT_FAILED.format(
+ project_name=project_name, error=e
+ ),
+ cs.Color.RED,
+ )
+ )
+ logger.exception(
+ cs.CLI_ERR_DELETE_PROJECT_FAILED.format(project_name=project_name, error=e)
+ )
+ raise typer.Exit(1) from e
+
+ if repo_path:
+ _delete_hash_cache(Path(repo_path))
+
+ _info(
+ style(
+ cs.CLI_MSG_PROJECT_DELETED.format(project_name=project_name),
+ cs.Color.GREEN,
+ )
+ )
+
+
if __name__ == "__main__":
app()
diff --git a/codebase_rag/cli_help.py b/codebase_rag/cli_help.py
index 96e816d9a..5d6114e27 100644
--- a/codebase_rag/cli_help.py
+++ b/codebase_rag/cli_help.py
@@ -10,6 +10,13 @@ class CLICommandName(StrEnum):
GRAPH_LOADER = "graph-loader"
LANGUAGE = "language"
DOCTOR = "doctor"
+ STATS = "stats"
+ DEAD_CODE = "dead-code"
+ DELETE_PROJECT = "delete-project"
+ DAEMON = "daemon"
+ WORKSPACE = "workspace"
+ STOP = "stop"
+ STATUS = "status"
APP_DESCRIPTION = (
@@ -26,6 +33,12 @@ class CLICommandName(StrEnum):
CMD_GRAPH_LOADER = "Load and display summary of exported graph JSON"
CMD_LANGUAGE = "Manage language grammars (add, remove, list)"
CMD_DOCTOR = "Verify that all dependencies and configurations are properly set up"
+CMD_STATS = "Display node and relationship statistics for the indexed graph"
+CMD_DEAD_CODE = (
+ "Report functions/methods that are unreachable from any entry point "
+ "(candidates for review, not a guaranteed delete list)"
+)
+CMD_DELETE_PROJECT = "Delete a single project from the shared graph database (keeps other projects intact)"
CMD_LANGUAGE_GROUP = "CLI for managing language grammars"
CMD_LANGUAGE_ADD = "Add a new language grammar to the project."
@@ -33,23 +46,86 @@ class CLICommandName(StrEnum):
CMD_LANGUAGE_REMOVE = "Remove a language from the project."
CMD_LANGUAGE_CLEANUP = "Clean up orphaned git modules that weren't properly removed."
+CMD_DAEMON = "Manage the shared cgr docker stack (memgraph + qdrant)"
+CMD_DAEMON_GROUP = "Manage the shared cgr docker stack (memgraph + qdrant)"
+CMD_DAEMON_UP = "Start the docker stack and wait until healthy."
+CMD_DAEMON_DOWN = "Stop the docker stack (preserves data volumes)."
+CMD_DAEMON_STATUS = "Show whether memgraph and qdrant are reachable."
+CMD_DAEMON_LOGS = "Tail docker compose logs for the stack."
+CMD_DAEMON_RESTART = "Restart the docker stack."
+
+CMD_WORKSPACE = "Manage cgr workspaces (named bundles of repos)"
+CMD_WORKSPACE_GROUP = "Manage cgr workspaces (named bundles of repos)"
+CMD_WORKSPACE_LIST = "List all workspaces."
+CMD_WORKSPACE_CREATE = "Create a new empty workspace."
+CMD_WORKSPACE_DELETE = "Delete a workspace TOML (does not touch indexed graph data)."
+CMD_WORKSPACE_SHOW = "Show a workspace's repos and project names."
+CMD_WORKSPACE_ADD_REPO = "Add a repo to a workspace."
+CMD_WORKSPACE_REMOVE_REPO = "Remove a repo from a workspace by path."
+
+HELP_WORKSPACE_DESCRIPTION = "Optional human-readable description."
+HELP_WORKSPACE_FORCE = "Overwrite an existing workspace with the same name."
+HELP_WORKSPACE_REPO_PROJECT_NAME = (
+ "Project name to associate with this repo (defaults to derive_project_name(repo))."
+)
+
+MSG_NO_WORKSPACES = "(no workspaces; create one with 'cgr workspace create ')"
+
+CMD_STOP = "Alias for `cgr daemon down`: stop the shared docker stack."
+CMD_STATUS = "Show daemon stack state plus last-sync timestamp per project."
+
+HELP_DAEMON_LOGS_FOLLOW = "Stream logs continuously (Ctrl+C to stop)."
+HELP_DAEMON_LOGS_SERVICE = (
+ "Limit logs to a specific service (memgraph, qdrant, lab). Default: all."
+)
+HELP_NO_START_STACK = (
+ "Skip auto-starting the docker stack. Useful when memgraph/qdrant run elsewhere."
+)
+HELP_NO_SYNC = (
+ "Skip the automatic incremental graph sync that runs before the agent starts."
+)
+HELP_PROJECTS = (
+ "Comma-separated list of project names to scope agent queries to. "
+ "Overrides --project-name. If omitted, defaults to the current repo's project."
+)
+HELP_WORKSPACE = (
+ "Open the agent over all projects defined in a cgr workspace TOML "
+ "(stored under ~/.cgr/workspaces/.toml)."
+)
+
HELP_BATCH_SIZE = "Number of buffered nodes/relationships before flushing to Memgraph"
HELP_MEMGRAPH_HOST = "Memgraph host"
HELP_MEMGRAPH_PORT = "Memgraph port"
HELP_ORCHESTRATOR = (
"Specify orchestrator as provider:model "
- "(e.g., ollama:llama3.2, openai:gpt-4, google:gemini-2.5-pro)"
+ "(e.g., ollama:llama3.2, openai:gpt-4, google:gemini-3.1-pro-preview)"
)
HELP_CYPHER_MODEL = (
"Specify cypher model as provider:model "
- "(e.g., ollama:codellama, google:gemini-2.5-flash)"
+ "(e.g., ollama:codellama, google:gemini-3-flash-preview)"
)
HELP_NO_CONFIRM = "Disable confirmation prompts for edit operations (YOLO mode)"
+HELP_NO_INSTRUCTIONS = (
+ "Skip loading project instructions from ~/.cgr.md and /.cgr.md "
+ "(useful when the consolidated memories are bloating the system prompt)"
+)
-HELP_REPO_PATH_RETRIEVAL = "Path to the target repository for code retrieval"
-HELP_REPO_PATH_INDEX = "Path to the target repository to index."
-HELP_REPO_PATH_OPTIMIZE = "Path to the repository to optimize"
+HELP_REPO_PATH_RETRIEVAL = (
+ "Path to the target repository for code retrieval (defaults to current directory)"
+)
+HELP_REPO_PATH_INDEX = (
+ "Path to the target repository to index (defaults to current directory)."
+)
+HELP_REPO_PATH_OPTIMIZE = (
+ "Path to the repository to optimize (defaults to current directory)"
+)
HELP_REPO_PATH_WATCH = "Path to the repository to watch."
+HELP_VERSION = "Show the version and exit."
+
+HELP_DEBOUNCE = "Debounce delay in seconds. Set to 0 to disable debouncing."
+HELP_MAX_WAIT = (
+ "Maximum wait time in seconds before forcing an update during continuous edits."
+)
HELP_UPDATE_GRAPH = "Update the knowledge graph by parsing the repository"
HELP_CLEAN_DB = "Clean the database before updating (use when adding first repo)"
@@ -73,6 +149,10 @@ class CLICommandName(StrEnum):
)
HELP_KEEP_SUBMODULE = "Keep the git submodule (default: remove it)"
+HELP_PROJECT_NAME = (
+ "Override the project name used as qualified-name prefix for all nodes. "
+ "Defaults to the repo directory name."
+)
HELP_EXCLUDE_PATTERNS = (
"Additional directories to exclude from indexing. Can be specified multiple times."
)
@@ -81,6 +161,60 @@ class CLICommandName(StrEnum):
"Without this flag, all directories matching ignore patterns are automatically excluded."
)
+HELP_ASK_AGENT = (
+ "Run a single query in non-interactive mode and exit. "
+ "Output is sent to stdout, useful for scripting."
+)
+
+HELP_QUERY_OUTPUT_FORMAT = (
+ "Output format for --ask-agent: 'table' (default) prints the plain answer; "
+ '\'json\' wraps it as {"query": ..., "response": ...} for scripting.'
+)
+
+HELP_MCP_TRANSPORT = "Transport mode: 'stdio' (default) or 'http'"
+HELP_MCP_HTTP_HOST = (
+ "Host to bind the HTTP server — only used when --transport http (default: 0.0.0.0)"
+)
+HELP_MCP_HTTP_PORT = (
+ "Port to bind the HTTP server — only used when --transport http (default: 8080)"
+)
+
+HELP_DEADCODE_PROJECT_NAME = (
+ "Project to scan (matches the Project node name). "
+ "If omitted, the sole indexed project is used."
+)
+HELP_DEADCODE_ENTRY_POINT = (
+ "Treat functions/methods whose qualified name ends with this value as "
+ "reachable roots. Repeatable."
+)
+HELP_DEADCODE_DECORATOR_ROOT = (
+ "Treat functions/methods carrying this decorator as reachable roots. "
+ "Extends the built-in set (route, task, fixture, command, ...). Repeatable."
+)
+HELP_DEADCODE_INCLUDE_TESTS = (
+ "Treat test code as reachable roots so production code it exercises is "
+ "not reported. On by default."
+)
+HELP_DEADCODE_CLASSES = (
+ "Also report unreachable classes. A class counts as used when it is "
+ "instantiated or subclassed by a reachable class, so a base whose only "
+ "subclass is itself unreachable is reported as part of the dead cluster. "
+ "Off by default: classes referenced only via type annotations, isinstance, "
+ "or dynamic lookups are not tracked and may be false positives."
+)
+HELP_DEADCODE_FORMAT = "Output format: 'table' (default) or 'json'."
+HELP_DEADCODE_OUTPUT = "Write the report to this file instead of stdout."
+HELP_DEADCODE_FAIL_ON_FOUND = (
+ "Exit with code 1 when any candidate is found (useful in CI)."
+)
+
+HELP_DELETE_PROJECT_NAME = (
+ "Name of the project to delete (matches the Project node name in the graph)."
+)
+HELP_DELETE_PROJECT_REPO_PATH = (
+ "Optional path to the project's repo. If supplied, its hash cache is removed too."
+)
+
CLI_COMMANDS: dict[CLICommandName, str] = {
CLICommandName.START: CMD_START,
CLICommandName.INDEX: CMD_INDEX,
@@ -90,4 +224,11 @@ class CLICommandName(StrEnum):
CLICommandName.GRAPH_LOADER: CMD_GRAPH_LOADER,
CLICommandName.LANGUAGE: CMD_LANGUAGE,
CLICommandName.DOCTOR: CMD_DOCTOR,
+ CLICommandName.STATS: CMD_STATS,
+ CLICommandName.DEAD_CODE: CMD_DEAD_CODE,
+ CLICommandName.DELETE_PROJECT: CMD_DELETE_PROJECT,
+ CLICommandName.DAEMON: CMD_DAEMON,
+ CLICommandName.WORKSPACE: CMD_WORKSPACE,
+ CLICommandName.STOP: CMD_STOP,
+ CLICommandName.STATUS: CMD_STATUS,
}
diff --git a/codebase_rag/config.py b/codebase_rag/config.py
index 31848e4d1..4c4a95857 100644
--- a/codebase_rag/config.py
+++ b/codebase_rag/config.py
@@ -1,5 +1,6 @@
from __future__ import annotations
+import os
from dataclasses import asdict, dataclass
from pathlib import Path
from typing import TypedDict, Unpack
@@ -44,11 +45,6 @@ class ApiKeyInfoEntry(TypedDict):
"url": "https://portal.azure.com/",
"name": "Azure OpenAI",
},
- cs.Provider.COHERE: {
- "env_var": "COHERE_API_KEY",
- "url": "https://dashboard.cohere.com/api-keys",
- "name": "Cohere",
- },
}
@@ -94,6 +90,9 @@ def format_missing_api_key_errors(
return error_msg
+LOCAL_PROVIDERS = frozenset({cs.Provider.OLLAMA})
+
+
@dataclass
class ModelConfig:
provider: str
@@ -113,8 +112,20 @@ def to_update_kwargs(self) -> ModelConfigKwargs:
return ModelConfigKwargs(**result)
def validate_api_key(self, role: str = cs.DEFAULT_MODEL_ROLE) -> None:
- local_providers = {cs.Provider.OLLAMA, cs.Provider.LOCAL, cs.Provider.VLLM}
- if self.provider.lower() in local_providers:
+ provider_lower = self.provider.lower()
+ provider_env_keys = {
+ cs.Provider.ANTHROPIC: cs.ENV_ANTHROPIC_API_KEY,
+ cs.Provider.AZURE: cs.ENV_AZURE_API_KEY,
+ }
+ env_key = provider_env_keys.get(provider_lower)
+ if (
+ provider_lower in LOCAL_PROVIDERS
+ or (
+ provider_lower == cs.Provider.GOOGLE
+ and self.provider_type == cs.GoogleProviderType.VERTEX
+ )
+ or (env_key and os.environ.get(env_key))
+ ):
return
if (
not self.api_key
@@ -139,6 +150,8 @@ class AppConfig(BaseSettings):
MEMGRAPH_HOST: str = "localhost"
MEMGRAPH_PORT: int = 7687
MEMGRAPH_HTTP_PORT: int = 7444
+ MEMGRAPH_USERNAME: str | None = None
+ MEMGRAPH_PASSWORD: str | None = None
LAB_PORT: int = 3000
MEMGRAPH_BATCH_SIZE: int = 1000
AGENT_RETRIES: int = 3
@@ -150,7 +163,7 @@ class AppConfig(BaseSettings):
ORCHESTRATOR_ENDPOINT: str | None = None
ORCHESTRATOR_PROJECT_ID: str | None = None
ORCHESTRATOR_REGION: str = cs.DEFAULT_REGION
- ORCHESTRATOR_PROVIDER_TYPE: str | None = None
+ ORCHESTRATOR_PROVIDER_TYPE: cs.GoogleProviderType | None = None
ORCHESTRATOR_THINKING_BUDGET: int | None = None
ORCHESTRATOR_SERVICE_ACCOUNT_FILE: str | None = None
@@ -160,7 +173,7 @@ class AppConfig(BaseSettings):
CYPHER_ENDPOINT: str | None = None
CYPHER_PROJECT_ID: str | None = None
CYPHER_REGION: str = cs.DEFAULT_REGION
- CYPHER_PROVIDER_TYPE: str | None = None
+ CYPHER_PROVIDER_TYPE: cs.GoogleProviderType | None = None
CYPHER_THINKING_BUDGET: int | None = None
CYPHER_SERVICE_ACCOUNT_FILE: str | None = None
@@ -171,6 +184,11 @@ def ollama_endpoint(self) -> str:
return f"{self.OLLAMA_BASE_URL.rstrip('/')}/v1"
TARGET_REPO_PATH: str = "."
+ CPP_FRONTEND: cs.CppFrontend = cs.CppFrontend.TREESITTER
+ CAPTURE_FUNCTION_LOCAL_DEFINITIONS: bool = Field(
+ True, validation_alias="CGR_CAPTURE_LOCAL_DEFINITIONS"
+ )
+ CGR_HOME: Path = Field(default_factory=lambda: Path.home() / ".cgr")
SHELL_COMMAND_TIMEOUT: int = 30
SHELL_COMMAND_ALLOWLIST: frozenset[str] = frozenset(
{
@@ -235,24 +253,41 @@ def ollama_endpoint(self) -> str:
)
QDRANT_DB_PATH: str = "./.qdrant_code_embeddings"
+ QDRANT_URL: str | None = None
QDRANT_COLLECTION_NAME: str = "code_embeddings"
QDRANT_VECTOR_DIM: int = 768
QDRANT_TOP_K: int = 5
+ QDRANT_UPSERT_RETRIES: int = Field(default=3, gt=0)
+ QDRANT_RETRY_BASE_DELAY: float = Field(default=0.5, gt=0)
+ QDRANT_BATCH_SIZE: int = Field(default=50, gt=0)
EMBEDDING_MAX_LENGTH: int = 512
EMBEDDING_PROGRESS_INTERVAL: int = 10
+ FLUSH_THREAD_POOL_SIZE: int = Field(default=4, gt=0)
+ FILE_FLUSH_INTERVAL: int = Field(default=500, gt=0)
+
CACHE_MAX_ENTRIES: int = 1000
CACHE_MAX_MEMORY_MB: int = 500
CACHE_EVICTION_DIVISOR: int = 10
CACHE_MEMORY_THRESHOLD_RATIO: float = 0.8
+ QUERY_RESULT_MAX_TOKENS: int = Field(default=16000, gt=0)
+ QUERY_RESULT_ROW_CAP: int = Field(default=500, gt=0)
+ QUERY_MEMORY_LIMIT_MB: int = Field(default=4096, gt=0)
+ QUERY_TIMEOUT_S: float = Field(default=60.0, gt=0)
+
OLLAMA_HEALTH_TIMEOUT: float = 5.0
+ LITELLM_HEALTH_TIMEOUT: float = 5.0
_active_orchestrator: ModelConfig | None = None
_active_cypher: ModelConfig | None = None
QUIET: bool = Field(False, validation_alias="CGR_QUIET")
+ MCP_HTTP_HOST: str = "0.0.0.0"
+ MCP_HTTP_PORT: int = 8080
+ MCP_HTTP_ENDPOINT_PATH: str = "/mcp"
+
def _get_default_config(self, role: str) -> ModelConfig:
role_upper = role.upper()
@@ -362,3 +397,34 @@ def load_cgrignore_patterns(repo_path: Path) -> CgrignorePatterns:
except OSError as e:
logger.warning(logs.CGRIGNORE_READ_FAILED.format(path=ignore_file, error=e))
return EMPTY_CGRIGNORE
+
+
+CGR_INSTRUCTIONS_FILENAME = ".cgr.md"
+GLOBAL_CGR_INSTRUCTIONS_PATH = Path.home() / CGR_INSTRUCTIONS_FILENAME
+
+
+def _read_cgr_instructions_file(path: Path) -> str | None:
+ if not path.is_file():
+ return None
+ try:
+ with path.open(encoding="utf-8") as f:
+ body = f.read().strip()
+ except OSError as e:
+ logger.warning(logs.CGR_INSTRUCTIONS_READ_FAILED.format(path=path, error=e))
+ return None
+ if not body:
+ return None
+ logger.info(logs.CGR_INSTRUCTIONS_LOADED.format(path=path, chars=len(body)))
+ return body
+
+
+def load_cgr_instructions(repo_path: Path | None) -> str | None:
+ global_body = _read_cgr_instructions_file(GLOBAL_CGR_INSTRUCTIONS_PATH)
+ repo_body = (
+ _read_cgr_instructions_file(repo_path / CGR_INSTRUCTIONS_FILENAME)
+ if repo_path is not None
+ else None
+ )
+ if global_body and repo_body:
+ return f"{global_body}\n\n---\n\n{repo_body}"
+ return global_body or repo_body
diff --git a/codebase_rag/constants.py b/codebase_rag/constants.py
index 4ef971d8a..e94b28637 100644
--- a/codebase_rag/constants.py
+++ b/codebase_rag/constants.py
@@ -20,9 +20,7 @@ class Provider(StrEnum):
OPENAI = "openai"
GOOGLE = "google"
AZURE = "azure"
- COHERE = "cohere"
- LOCAL = "local"
- VLLM = "vllm"
+ LITELLM_PROXY = "litellm_proxy"
class Color(StrEnum):
@@ -36,8 +34,15 @@ class Color(StrEnum):
class KeyBinding(StrEnum):
CTRL_J = "c-j"
+ CTRL_E = "c-e"
ENTER = "enter"
CTRL_C = "c-c"
+ SHIFT_TAB = "s-tab"
+
+
+class PermissionMode(StrEnum):
+ NORMAL = "normal"
+ YOLO = "yolo"
class StyleModifier(StrEnum):
@@ -89,7 +94,7 @@ class FileAction(StrEnum):
EXT_IXX = ".ixx"
EXT_CPPM = ".cppm"
EXT_CCM = ".ccm"
-EXT_CS = ".cs"
+EXT_C = ".c"
EXT_PHP = ".php"
EXT_LUA = ".lua"
@@ -101,6 +106,7 @@ class FileAction(StrEnum):
GO_EXTENSIONS = (EXT_GO,)
SCALA_EXTENSIONS = (EXT_SCALA, EXT_SC)
JAVA_EXTENSIONS = (EXT_JAVA,)
+C_EXTENSIONS = (EXT_C,)
CPP_EXTENSIONS = (
EXT_CPP,
EXT_H,
@@ -113,7 +119,6 @@ class FileAction(StrEnum):
EXT_CPPM,
EXT_CCM,
)
-CS_EXTENSIONS = (EXT_CS,)
PHP_EXTENSIONS = (EXT_PHP,)
LUA_EXTENSIONS = (EXT_LUA,)
@@ -131,6 +136,10 @@ class FileAction(StrEnum):
ENV_OPENAI_API_KEY = "OPENAI_API_KEY"
ENV_GOOGLE_API_KEY = "GOOGLE_API_KEY"
+ENV_ANTHROPIC_API_KEY = "ANTHROPIC_API_KEY"
+ENV_AZURE_API_KEY = "AZURE_API_KEY"
+ENV_AZURE_ENDPOINT = "AZURE_OPENAI_ENDPOINT"
+ENV_AZURE_API_VERSION = "AZURE_API_VERSION"
HELP_ARG = "help"
@@ -140,6 +149,11 @@ class GoogleProviderType(StrEnum):
VERTEX = "vertex"
+class CppFrontend(StrEnum):
+ TREESITTER = "treesitter"
+ LIBCLANG = "libclang"
+
+
# (H) Provider endpoints
OPENAI_DEFAULT_ENDPOINT = "https://api.openai.com/v1"
OLLAMA_HEALTH_PATH = "/api/tags"
@@ -150,11 +164,14 @@ class GoogleProviderType(StrEnum):
HTTP_OK = 200
UNIXCODER_MODEL = "microsoft/unixcoder-base"
+EMBEDDING_DEFAULT_BATCH_SIZE = 64
+EMBEDDING_CACHE_FILENAME = ".embedding_cache.json"
KEY_NODES = "nodes"
KEY_RELATIONSHIPS = "relationships"
KEY_NODE_ID = "node_id"
KEY_LABELS = "labels"
+KEY_LABEL = "label"
KEY_PROPERTIES = "properties"
KEY_FROM_ID = "from_id"
KEY_TO_ID = "to_id"
@@ -168,9 +185,12 @@ class GoogleProviderType(StrEnum):
KEY_PARSER = "parser"
KEY_NAME = "name"
KEY_QUALIFIED_NAME = "qualified_name"
+KEY_QUERY = "query"
+KEY_RESPONSE = "response"
KEY_START_LINE = "start_line"
KEY_END_LINE = "end_line"
KEY_PATH = "path"
+KEY_ABSOLUTE_PATH = "absolute_path"
KEY_EXTENSION = "extension"
KEY_MODULE_TYPE = "module_type"
KEY_IMPLEMENTS_MODULE = "implements_module"
@@ -209,12 +229,23 @@ class GoogleProviderType(StrEnum):
ONEOF_EXTERNAL_PACKAGE = "external_package"
ONEOF_MODULE_IMPLEMENTATION = "module_implementation"
ONEOF_MODULE_INTERFACE = "module_interface"
+ONEOF_INTERFACE = "interface_node"
+ONEOF_ENUM = "enum_node"
+ONEOF_TYPE = "type_node"
+ONEOF_UNION = "union_node"
# (H) CLI error and info messages
CLI_ERR_OUTPUT_REQUIRES_UPDATE = (
"Error: --output/-o option requires --update-graph to be specified."
)
CLI_ERR_ONLY_JSON = "Error: Currently only JSON format is supported."
+CLI_ERR_JSON_REQUIRES_ASK_AGENT = (
+ "Error: --output-format json requires --ask-agent/-a; "
+ "it only applies to single-query output."
+)
+CLI_ERR_PATH_NOT_EXISTS = "Error: --repo-path does not exist: {path}"
+CLI_ERR_PATH_NOT_DIR = "Error: --repo-path is not a directory: {path}"
+CLI_WARN_NOT_GIT_REPO = "Warning: --repo-path is not a Git repository: {path}"
CLI_ERR_STARTUP = "Startup Error: {error}"
CLI_ERR_CONFIG = "Configuration Error: {error}"
CLI_ERR_INDEXING = "An error occurred during indexing: {error}"
@@ -223,7 +254,34 @@ class GoogleProviderType(StrEnum):
CLI_ERR_MCP_SERVER = "MCP Server Error: {error}"
CLI_MSG_UPDATING_GRAPH = "Updating knowledge graph for: {path}"
+CLI_MSG_SYNCING_GRAPH = "Syncing knowledge graph for: {path} (use --no-sync to skip)"
+CLI_MSG_WORKSPACE_SYNCING = "Syncing workspace '{name}' ({count} repos)..."
+CLI_MSG_WORKSPACE_SYNC_REPO = (
+ "[{idx}/{total}] Syncing {path} as project '{project_name}'"
+)
+CLI_MSG_WORKSPACE_EMPTY = (
+ "Workspace '{name}' has no repos (use cgr workspace add-repo)."
+)
+MSG_SYNCING_KNOWLEDGE_GRAPH = (
+ "[bold cyan]Syncing knowledge graph[/bold cyan] (incremental, --no-sync to skip)"
+)
+MSG_SYNCING_WORKSPACE = (
+ "[bold cyan]Syncing workspace '{name}'[/bold cyan] ({count} repos)"
+)
+CLI_MSG_SYNC_SKIPPED = "Knowledge graph already in sync for '{project}' ({elapsed:.2f}s, no changes detected)."
+CLI_MSG_SYNC_DONE = "Knowledge graph sync done for '{project}' in {elapsed:.2f}s."
CLI_MSG_CLEANING_DB = "Cleaning database..."
+CLI_MSG_CLEANING_HASH_CACHE = "Removing hash cache: {path}"
+CLI_MSG_CLEAN_DONE = "Clean completed successfully!"
+CLI_MSG_DELETING_PROJECT = "Deleting project '{project_name}' from the graph..."
+CLI_MSG_PROJECT_DELETED = "Project '{project_name}' deleted successfully."
+CLI_ERR_PROJECT_NOT_FOUND = (
+ "Project '{project_name}' not found. Available projects: {projects}"
+)
+CLI_ERR_PROJECT_NAME_REQUIRED = (
+ "Error: --name is required and must be a non-empty project name."
+)
+CLI_ERR_DELETE_PROJECT_FAILED = "Failed to delete project '{project_name}': {error}"
CLI_MSG_EXPORTING_TO = "Exporting graph to: {path}"
CLI_MSG_GRAPH_UPDATED = "Graph update completed!"
CLI_MSG_APP_TERMINATED = "\nApplication terminated by user."
@@ -234,10 +292,39 @@ class GoogleProviderType(StrEnum):
CLI_MSG_EXPORTING_DATA = "Exporting graph data..."
CLI_MSG_OPTIMIZATION_TERMINATED = "\nOptimization session terminated by user."
CLI_MSG_MCP_TERMINATED = "\nMCP server terminated by user."
+PACKAGE_NAME = "code-graph-rag"
+CLI_MSG_VERSION = "{package} version {version}"
CLI_MSG_HINT_TARGET_REPO = (
"\nHint: Make sure TARGET_REPO_PATH environment variable is set."
)
CLI_MSG_GRAPH_SUMMARY = "Graph Summary:"
+CLI_MSG_CONNECTING_STATS = "Fetching graph statistics..."
+CLI_STATS_NODE_TITLE = "Node Statistics"
+CLI_STATS_REL_TITLE = "Relationship Statistics"
+CLI_STATS_COL_NODE_TYPE = "Node Type"
+CLI_STATS_COL_REL_TYPE = "Relationship Type"
+CLI_STATS_COL_COUNT = "Count"
+CLI_STATS_TOTAL_NODES = "Total Nodes"
+CLI_STATS_TOTAL_RELS = "Total Relationships"
+CLI_STATS_UNKNOWN = "Unknown"
+CLI_ERR_STATS_FAILED = "Failed to get graph statistics: {error}"
+
+CLI_DEADCODE_CONNECTING = "Scanning for unreachable functions and methods..."
+CLI_DEADCODE_TABLE_TITLE = "Dead Code Candidates ({project_name})"
+CLI_DEADCODE_COL_KIND = "Kind"
+CLI_DEADCODE_COL_QUALIFIED_NAME = "Qualified Name"
+CLI_DEADCODE_COL_LINES = "Lines"
+CLI_DEADCODE_LINE_RANGE = "{start}-{end}"
+CLI_DEADCODE_SUMMARY = "{count} candidate(s) for review."
+CLI_DEADCODE_NONE = "No unreachable functions or methods found."
+CLI_DEADCODE_WRITTEN = "Wrote {count} candidate(s) to {path}"
+CLI_ERR_DEADCODE_FAILED = "Failed to scan for dead code: {error}"
+CLI_ERR_DEADCODE_NO_PROJECTS = (
+ "No projects found in the graph. Index a repository first with 'cgr start'."
+)
+CLI_ERR_DEADCODE_AMBIGUOUS_PROJECT = (
+ "Multiple projects found: {projects}. Specify which one with --project-name/-n."
+)
CLI_MSG_AUTO_EXCLUDE = (
"Auto-excluding common directories (venv, node_modules, .git, etc.). "
"Use --interactive-setup to customize."
@@ -247,9 +334,7 @@ class GoogleProviderType(StrEnum):
UI_NEW_FILE_HEADER = "[bold cyan]New file: {path}[/bold cyan]"
UI_SHELL_COMMAND_HEADER = "[bold cyan]Shell command:[/bold cyan]"
UI_TOOL_APPROVAL = "[bold yellow]⚠️ Tool '{tool_name}' requires approval:[/bold yellow]"
-UI_FEEDBACK_PROMPT = (
- "[bold yellow]Feedback (why rejected, or press Enter to skip)[/bold yellow]"
-)
+UI_FEEDBACK_PROMPT = "Feedback (why rejected, or press Enter to skip)"
UI_OPTIMIZATION_START = (
"[bold green]Starting {language} optimization session...[/bold green]"
)
@@ -268,7 +353,7 @@ class GoogleProviderType(StrEnum):
UI_MODEL_SWITCHED = "[bold green]Model switched to: {model}[/bold green]"
UI_MODEL_CURRENT = "[bold cyan]Current model: {model}[/bold cyan]"
UI_MODEL_SWITCH_ERROR = "[bold red]Failed to switch model: {error}[/bold red]"
-UI_MODEL_USAGE = "[bold yellow]Usage: /model (e.g., /model google:gemini-2.0-flash)[/bold yellow]"
+UI_MODEL_USAGE = "[bold yellow]Usage: /model (e.g., /model google:gemini-3.1-pro-preview)[/bold yellow]"
UI_HELP_COMMANDS = """[bold cyan]Available commands:[/bold cyan]
/model - Switch to a different model
/model - Show current model
@@ -296,6 +381,9 @@ class GoogleProviderType(StrEnum):
# (H) Qualified name separators
SEPARATOR_DOT = "."
SEPARATOR_SLASH = "/"
+# (H) Disambiguates definitions that share one qualified name (if/else import
+# (H) fallbacks, typing.overload, try/except fallbacks): "@".
+DUP_QN_MARKER = "@"
# (H) Path navigation
PATH_CURRENT_DIR = "."
@@ -318,6 +406,42 @@ class UniqueKeyType(StrEnum):
QUALIFIED_NAME = KEY_QUALIFIED_NAME
+class DeadCodeFormat(StrEnum):
+ TABLE = "table"
+ JSON = "json"
+
+
+class QueryFormat(StrEnum):
+ TABLE = "table"
+ JSON = "json"
+
+
+# (H) Decorators whose presence marks a function/method as an implicit entry point
+# (H) (web routes, task/flow handlers, fixtures, CLI commands, event listeners).
+DEFAULT_ROOT_DECORATORS: frozenset[str] = frozenset(
+ {
+ "route",
+ "get",
+ "post",
+ "put",
+ "delete",
+ "patch",
+ "websocket",
+ "task",
+ "flow",
+ "fixture",
+ "command",
+ "cli",
+ "app",
+ "on_event",
+ "listener",
+ }
+)
+
+# (H) Substrings in a node's file path that mark it as test code.
+TEST_PATH_PATTERNS: tuple[str, ...] = ("test_", "_test", "conftest", "/tests/")
+
+
class NodeLabel(StrEnum):
PROJECT = "Project"
PACKAGE = "Package"
@@ -377,6 +501,7 @@ class RelationshipType(StrEnum):
IMPLEMENTS = "IMPLEMENTS"
OVERRIDES = "OVERRIDES"
CALLS = "CALLS"
+ INSTANTIATES = "INSTANTIATES"
DEPENDS_ON_EXTERNAL = "DEPENDS_ON_EXTERNAL"
@@ -417,14 +542,21 @@ class RelationshipType(StrEnum):
# (H) Cypher queries
CYPHER_DEFAULT_LIMIT = 50
-CYPHER_QUERY_EMBEDDINGS = """
+_CYPHER_EMBEDDING_BASE = """
MATCH (m:Module)-[:DEFINES]->(n)
WHERE (n:Function OR n:Method)
- AND m.qualified_name STARTS WITH $project_name + '.'
-RETURN id(n) AS node_id, n.qualified_name AS qualified_name,
+ AND m.qualified_name STARTS WITH ($project_name + '.')
+"""
+
+CYPHER_QUERY_EMBEDDINGS = (
+ _CYPHER_EMBEDDING_BASE
+ + """RETURN id(n) AS node_id, n.qualified_name AS qualified_name,
n.start_line AS start_line, n.end_line AS end_line,
m.path AS path
"""
+)
+
+CYPHER_QUERY_PROJECT_NODE_IDS = _CYPHER_EMBEDDING_BASE + "RETURN id(n) AS node_id\n"
class SupportedLanguage(StrEnum):
@@ -435,8 +567,8 @@ class SupportedLanguage(StrEnum):
GO = "go"
SCALA = "scala"
JAVA = "java"
+ C = "c"
CPP = "cpp"
- CSHARP = "c-sharp"
PHP = "php"
LUA = "lua"
@@ -468,6 +600,11 @@ class LanguageMetadata(NamedTuple):
"Interfaces, type aliases, enums, namespaces, ES6/CommonJS modules",
"TypeScript",
),
+ SupportedLanguage.C: LanguageMetadata(
+ LanguageStatus.FULL,
+ "Functions, structs, unions, enums, preprocessor includes",
+ "C",
+ ),
SupportedLanguage.CPP: LanguageMetadata(
LanguageStatus.FULL,
"Constructors, destructors, operator overloading, templates, lambdas, C++20 modules, namespaces",
@@ -498,14 +635,9 @@ class LanguageMetadata(NamedTuple):
"Case classes, objects",
"Scala",
),
- SupportedLanguage.CSHARP: LanguageMetadata(
- LanguageStatus.DEV,
- "Classes, interfaces, generics (planned)",
- "C#",
- ),
SupportedLanguage.PHP: LanguageMetadata(
- LanguageStatus.DEV,
- "Classes, functions, namespaces",
+ LanguageStatus.FULL,
+ "Classes, interfaces, traits, enums, namespaces, PHP 8 attributes",
"PHP",
),
}
@@ -551,7 +683,6 @@ class LanguageMetadata(NamedTuple):
IMPORT_NODES_FROM = ("import_from_statement",)
IMPORT_NODES_MODULE = ("lexical_declaration", "export_statement")
IMPORT_NODES_INCLUDE = ("preproc_include",)
-IMPORT_NODES_USING = ("using_directive",)
# (H) JS/TS specific node types
JS_TS_FUNCTION_NODES = (
@@ -584,10 +715,16 @@ class LanguageMetadata(NamedTuple):
FIELD_MODULE_NAME = "module_name"
FIELD_ARGUMENTS = "arguments"
FIELD_BODY = "body"
+FIELD_RETURN_TYPE = "return_type"
FIELD_CONSTRUCTOR = "constructor"
FIELD_DECLARATOR = "declarator"
FIELD_PARAMETERS = "parameters"
+FIELD_RECEIVER = "receiver"
FIELD_TYPE = "type"
+# (H) Rust impl `trait`/`type` fields and a trait's supertrait `bounds`.
+FIELD_TRAIT = "trait"
+FIELD_BOUNDS = "bounds"
+TS_RS_TRAIT_BOUNDS = "trait_bounds"
FIELD_VALUE = "value"
FIELD_LEFT = "left"
FIELD_RIGHT = "right"
@@ -601,7 +738,35 @@ class LanguageMetadata(NamedTuple):
METHOD_ITEMS = "items"
# (H) Image file extensions for chat image handling
-IMAGE_EXTENSIONS = (".png", ".jpg", ".jpeg", ".gif")
+MULTIMODAL_EXTENSIONS = (".png", ".jpg", ".jpeg", ".gif", ".webp", ".pdf")
+MIME_TYPE_PDF = "application/pdf"
+MIME_TYPE_FALLBACK = "application/octet-stream"
+YES_ANSWER = "y"
+YES_ANSWERS = frozenset({"y", "yes", ""})
+NO_ANSWERS = frozenset({"n", "no"})
+SHIFT_TAB_ESCAPE = b"\x1b[Z"
+DIFF_GIT_HEADER = "diff --git "
+MARKDOWN_FENCE = "```"
+MARKDOWN_FENCE_DIFF = "```diff"
+DIFF_CONTINUATION_PREFIXES = (
+ "diff --git ",
+ "index ",
+ "--- ",
+ "+++ ",
+ "@@ ",
+ "+",
+ "-",
+ " ",
+ "\\ ",
+ "new file mode",
+ "deleted file mode",
+ "old mode",
+ "new mode",
+ "rename from ",
+ "rename to ",
+ "similarity index ",
+ "Binary files ",
+)
# (H) CLI exit commands
EXIT_COMMANDS = frozenset({"exit", "quit"})
@@ -670,6 +835,7 @@ class DiffMarker:
MSG_CONNECTED_MEMGRAPH = "Successfully connected to Memgraph."
MSG_THINKING_CANCELLED = "Thinking cancelled."
MSG_TIMEOUT_FORMAT = "Operation timed out after {timeout} seconds."
+MSG_TOOL_CALL_CANCELLED = "Tool call cancelled by user."
MSG_CHAT_INSTRUCTIONS = (
"Ask questions about your codebase graph. Type 'exit' or 'quit' to end."
)
@@ -679,7 +845,65 @@ class DiffMarker:
OPTIMIZATION_TABLE_TITLE = "Optimization Session Configuration"
PROMPT_ASK_QUESTION = "Ask a question"
PROMPT_YOUR_RESPONSE = "Your response"
-MULTILINE_INPUT_HINT = "(Press Ctrl+J to submit, Enter for new line)"
+MULTILINE_INPUT_HINT = (
+ "(Press Ctrl+J or Ctrl+E to submit, Enter for new line, Shift+Tab to toggle mode)"
+)
+PERMISSION_MODE_NORMAL_LABEL = "● Normal mode (asks before destructive)"
+PERMISSION_MODE_YOLO_LABEL = "● YOLO mode (auto-approve, allowlist off)"
+PERMISSION_MODE_TOGGLED = "Permission mode: {label}"
+STATUS_BAR_BRANCH_CLEAN_HTML = (
+ ''
+)
+STATUS_BAR_BRANCH_DIRTY_HTML = (
+ ''
+)
+STATUS_BAR_BRANCH_CLEAN_PLAIN = " ⎇ {branch} "
+STATUS_BAR_BRANCH_DIRTY_PLAIN = " ⎇ {branch} ± "
+STATUS_BAR_BRANCH_RICH_TEXT = " ⎇ {branch}{marker} "
+STATUS_BAR_CLEAN_STYLE = "black on green"
+STATUS_BAR_DIRTY_STYLE = "black on yellow"
+STATUS_BAR_DIRTY_MARKER = " ±"
+STATUS_BAR_SPINNER = "dots"
+STATUS_BAR_SEPARATOR_CHAR = "─"
+STATUS_BAR_SEPARATOR_COLOR = "#666666"
+STATUS_BAR_TOKEN_HTML = ' '
+STATUS_BAR_CONFIG_COLOR = "#888888"
+STATUS_BAR_CONFIG_LABEL_COLOR = "#5fafd7"
+STATUS_BAR_CONFIG_SEPARATOR = " │ "
+STATUS_BAR_CONFIG_LABEL_O = "O"
+STATUS_BAR_CONFIG_LABEL_C = "C"
+STATUS_BAR_CONFIG_LABEL_EDIT = "edit"
+STATUS_BAR_CONFIG_LABEL_INSTRUCTIONS = "instructions"
+STATUS_BAR_CONFIG_LABEL_REPO = "repo"
+STATUS_BAR_EDIT_ON = "on"
+STATUS_BAR_EDIT_OFF = "off"
+TOKEN_THRESHOLD_WARNING = 50
+TOKEN_THRESHOLD_CRITICAL = 80
+TOKEN_COLOR_OK = "green"
+TOKEN_COLOR_WARNING = "yellow"
+TOKEN_COLOR_CRITICAL = "red"
+
+ANTHROPIC_COUNT_TOKENS_URL = "https://api.anthropic.com/v1/messages/count_tokens"
+ANTHROPIC_API_VERSION = "2023-06-01"
+ANTHROPIC_HEADER_API_KEY = "x-api-key"
+ANTHROPIC_HEADER_VERSION = "anthropic-version"
+HEADER_CONTENT_TYPE = "content-type"
+CONTENT_TYPE_JSON = "application/json"
+ANTHROPIC_COUNT_TIMEOUT_S = 10.0
+
+DEFAULT_CONTEXT_WINDOW = 200_000
+MODEL_CONTEXT_WINDOWS: dict[str, int] = {
+ "claude-opus-4-7": 1_000_000,
+ "claude-opus-4-6": 200_000,
+ "claude-opus-4-5": 200_000,
+ "claude-opus-4-1": 200_000,
+ "claude-opus-4-0": 200_000,
+ "claude-sonnet-4-6": 200_000,
+ "claude-sonnet-4-5": 200_000,
+ "claude-sonnet-4-0": 200_000,
+ "claude-haiku-4-5": 200_000,
+ "claude-haiku-4-0": 200_000,
+}
# (H) Interactive setup prompt - grouped view
INTERACTIVE_TITLE_GROUPED = "Detected Directories (will be excluded unless kept)"
@@ -723,6 +947,7 @@ class DiffMarker:
INPLACE_FLAG = "--inplace"
LANG_ATTR_PREFIX = "language_"
LANG_ATTR_TYPESCRIPT = "language_typescript"
+LANG_ATTR_PHP = "language_php"
class TreeSitterModule(StrEnum):
@@ -733,8 +958,10 @@ class TreeSitterModule(StrEnum):
GO = "tree_sitter_go"
SCALA = "tree_sitter_scala"
JAVA = "tree_sitter_java"
+ C = "tree_sitter_c"
CPP = "tree_sitter_cpp"
LUA = "tree_sitter_lua"
+ PHP = "tree_sitter_php"
# (H) Query dict keys
@@ -839,10 +1066,34 @@ class TreeSitterModule(StrEnum):
class EventType(StrEnum):
MODIFIED = "modified"
CREATED = "created"
+ DELETED = "deleted"
-CYPHER_DELETE_MODULE = "MATCH (m:Module {path: $path})-[*0..]->(c) DETACH DELETE m, c"
+CYPHER_DELETE_MODULE = (
+ "MATCH (m:Module {path: $path}) "
+ "OPTIONAL MATCH (m)-[:DEFINES|DEFINES_METHOD*0..]->(c) "
+ "DETACH DELETE m, c"
+)
+CYPHER_DELETE_FILE = "MATCH (f:File {path: $path}) DETACH DELETE f"
+CYPHER_DELETE_FOLDER = "MATCH (f:Folder {path: $path}) DETACH DELETE f"
CYPHER_DELETE_CALLS = "MATCH ()-[r:CALLS]->() DELETE r"
+# (H) Removes external import-target Module nodes that no module imports anymore
+# (H) (e.g. an imported name that was renamed/removed on an incremental rebuild).
+CYPHER_DELETE_ORPHAN_EXTERNAL_MODULES = (
+ "MATCH (m:Module) WHERE m.is_external = true AND NOT (m)<--() DETACH DELETE m"
+)
+
+# (H) Queries for orphan pruning — returns all paths stored in the graph
+CYPHER_ALL_FILE_PATHS = (
+ "MATCH (f:File) RETURN f.path AS path, f.absolute_path AS absolute_path"
+)
+CYPHER_ALL_MODULE_PATHS_INTERNAL = (
+ "MATCH (m:Module) WHERE m.is_external IS NULL OR m.is_external = false "
+ "RETURN m.path AS path, m.qualified_name AS qualified_name"
+)
+CYPHER_ALL_FOLDER_PATHS = (
+ "MATCH (f:Folder) RETURN f.path AS path, f.absolute_path AS absolute_path"
+)
REALTIME_LOGGER_FORMAT = (
"{time:YYYY-MM-DD HH:mm:ss.SSS} | "
@@ -853,6 +1104,11 @@ class EventType(StrEnum):
WATCHER_SLEEP_INTERVAL = 1
LOG_LEVEL_INFO = "INFO"
+LOG_LEVEL_ERROR = "ERROR"
+
+# (H) Debounce settings for realtime watcher
+DEFAULT_DEBOUNCE_SECONDS = 5
+DEFAULT_MAX_WAIT_SECONDS = 30
class Architecture(StrEnum):
@@ -880,8 +1136,11 @@ class Architecture(StrEnum):
PYINSTALLER_ARG_COLLECT_ALL = "--collect-all"
PYINSTALLER_ARG_COLLECT_DATA = "--collect-data"
PYINSTALLER_ARG_HIDDEN_IMPORT = "--hidden-import"
+PYINSTALLER_ARG_EXCLUDE_MODULE = "--exclude-module"
PYINSTALLER_ENTRY_POINT = "main.py"
+PYINSTALLER_EXCLUDED_MODULES = ["logfire"]
+
# (H) TOML parsing constants
TOML_KEY_PROJECT = "project"
TOML_KEY_OPTIONAL_DEPS = "optional-dependencies"
@@ -905,6 +1164,7 @@ class Architecture(StrEnum):
PyInstallerPackage(name="loguru", collect_all=True),
PyInstallerPackage(name="toml", collect_all=True),
PyInstallerPackage(name="protobuf", collect_all=True),
+ PyInstallerPackage(name="genai_prices", collect_all=True),
]
ALLOWED_COMMENT_MARKERS = frozenset(
@@ -961,6 +1221,46 @@ class UniXcoderMode(StrEnum):
CYPHER_SEMICOLON = ";"
CYPHER_BACKTICK = "`"
CYPHER_MATCH_KEYWORD = "MATCH"
+CYPHER_DANGEROUS_KEYWORDS: frozenset[str] = frozenset(
+ {
+ "DELETE",
+ "DETACH",
+ "DROP",
+ "CREATE INDEX",
+ "CREATE CONSTRAINT",
+ "REMOVE",
+ "SET",
+ "MERGE",
+ "CREATE",
+ "LOAD CSV",
+ "FOREACH",
+ }
+)
+
+CYPHER_ALLOWED_PROCEDURE_PREFIXES: frozenset[str] = frozenset(
+ {
+ "algo.",
+ "betweenness_centrality.",
+ "biconnected_components.",
+ "bridges.",
+ "community_detection.",
+ "cycles.",
+ "degree_centrality.",
+ "graph_analyzer.",
+ "graph_util.",
+ "igraphalg.",
+ "katz_centrality.",
+ "leiden_community_detection.",
+ "neighbors.",
+ "node_similarity.",
+ "nxalg.",
+ "pagerank.",
+ "path.",
+ "schema.",
+ "weakly_connected_components.",
+ "wcc.",
+ }
+)
# (H) Tool success messages
MSG_SURGICAL_SUCCESS = "Successfully applied surgical code replacement in: {path}"
@@ -1105,12 +1405,23 @@ class UniXcoderMode(StrEnum):
# (H) Query tool messages
QUERY_NOT_AVAILABLE = "N/A"
DICT_KEY_RESULTS = "results"
+TIKTOKEN_ENCODING = "cl100k_base"
QUERY_SUMMARY_SUCCESS = "Successfully retrieved {count} item(s) from the graph."
+QUERY_SUMMARY_TRUNCATED = (
+ "Results truncated: showing {kept} of {total} items (~{tokens} tokens, limit {max_tokens}). "
+ "Refine your query for more specific results."
+)
QUERY_SUMMARY_TRANSLATION_FAILED = (
"I couldn't translate your request into a database query. Error: {error}"
)
QUERY_SUMMARY_DB_ERROR = "There was an error querying the database: {error}"
+QUERY_SUMMARY_TIMEOUT = (
+ "Query exceeded the {timeout:.1f}s timeout and was cancelled. "
+ "Avoid unbounded traversals; add depth bounds or use a graph-algorithm procedure."
+)
QUERY_RESULTS_PANEL_TITLE = "[bold blue]Cypher Query Results[/bold blue]"
+CYPHER_MEMORY_LIMIT_SUFFIX = " QUERY MEMORY LIMIT {mb} MB"
+CYPHER_MEMORY_LIMIT_TOKEN = "QUERY MEMORY LIMIT"
# (H) File editor constants
TMP_EXTENSION = ".tmp"
@@ -1569,6 +1880,13 @@ class CppNodeType(StrEnum):
# (H) Gemfile parsing patterns
GEMFILE_GEM_PREFIX = "gem "
+# (H) Incremental update hash cache
+HASH_CACHE_FILENAME = ".cgr-hash-cache.json"
+DIR_MTIMES_FILENAME = ".cgr-dir-mtimes.json"
+GIT_DIR_NAME = ".git"
+ROOT_DIR_KEY = "."
+JSON_EMPTY_OBJECT = "{}"
+
# (H) Import processor cache config
IMPORT_CACHE_TTL = 3600
IMPORT_CACHE_DIR = ".cache/codebase_rag"
@@ -1666,6 +1984,11 @@ class CppNodeType(StrEnum):
# (H) Tree-sitter Go node types
TS_GO_TYPE_DECLARATION = "type_declaration"
+TS_GO_TYPE_SPEC = "type_spec"
+TS_GO_TYPE_ALIAS = "type_alias"
+TS_GO_STRUCT_TYPE = "struct_type"
+TS_GO_INTERFACE_TYPE = "interface_type"
+TS_GO_PARAMETER_DECLARATION = "parameter_declaration"
TS_GO_SOURCE_FILE = "source_file"
TS_GO_FUNCTION_DECLARATION = "function_declaration"
TS_GO_METHOD_DECLARATION = "method_declaration"
@@ -1680,23 +2003,28 @@ class CppNodeType(StrEnum):
TS_SCALA_FUNCTION_DEFINITION = "function_definition"
TS_SCALA_FUNCTION_DECLARATION = "function_declaration"
TS_SCALA_CALL_EXPRESSION = "call_expression"
-TS_SCALA_GENERIC_FUNCTION = "generic_function"
+# (H) Shared tree-sitter node type: a call with explicit type args, e.g. Rust
+# (H) turbofish `f::()` and Scala `f[T]()`. Its `function` field holds the
+# (H) actual callee (identifier or scoped_identifier).
+TS_GENERIC_FUNCTION = "generic_function"
+TS_SCALA_GENERIC_FUNCTION = TS_GENERIC_FUNCTION
TS_SCALA_FIELD_EXPRESSION = "field_expression"
TS_SCALA_INFIX_EXPRESSION = "infix_expression"
TS_SCALA_IMPORT_DECLARATION = "import_declaration"
-# (H) Tree-sitter C# node types
-TS_CS_STRUCT_DECLARATION = "struct_declaration"
-TS_CS_COMPILATION_UNIT = "compilation_unit"
-TS_CS_DESTRUCTOR_DECLARATION = "destructor_declaration"
-TS_CS_LOCAL_FUNCTION_STATEMENT = "local_function_statement"
-TS_CS_FUNCTION_POINTER_TYPE = "function_pointer_type"
-TS_CS_ANONYMOUS_METHOD_EXPRESSION = "anonymous_method_expression"
-TS_CS_LAMBDA_EXPRESSION = "lambda_expression"
-TS_CS_INVOCATION_EXPRESSION = "invocation_expression"
-
# (H) Tree-sitter PHP node types
+TS_PHP_FUNCTION_DEFINITION = "function_definition"
+TS_PHP_METHOD_DECLARATION = "method_declaration"
TS_PHP_TRAIT_DECLARATION = "trait_declaration"
+# (H) PHP inheritance clauses: `extends ...` (base_clause, for class AND
+# (H) interface) and `implements ...` (class_interface_clause); each lists `name`
+# (H) nodes naming the base types.
+TS_PHP_BASE_CLAUSE = "base_clause"
+TS_PHP_CLASS_INTERFACE_CLAUSE = "class_interface_clause"
+TS_PHP_NAME = "name"
+# (H) PHP fully-qualified base (`\Exception`, `\App\Base`); its trailing `name`
+# (H) child is the simple name cgr resolves against.
+TS_PHP_QUALIFIED_NAME = "qualified_name"
TS_PHP_FUNCTION_STATIC_DECLARATION = "function_static_declaration"
TS_PHP_ANONYMOUS_FUNCTION = "anonymous_function"
TS_PHP_ARROW_FUNCTION = "arrow_function"
@@ -1704,6 +2032,20 @@ class CppNodeType(StrEnum):
TS_PHP_SCOPED_CALL_EXPRESSION = "scoped_call_expression"
TS_PHP_FUNCTION_CALL_EXPRESSION = "function_call_expression"
TS_PHP_NULLSAFE_MEMBER_CALL_EXPRESSION = "nullsafe_member_call_expression"
+TS_PHP_OBJECT_CREATION_EXPRESSION = "object_creation_expression"
+TS_PHP_NAMESPACE_DEFINITION = "namespace_definition"
+TS_PHP_NAMESPACE_USE_DECLARATION = "namespace_use_declaration"
+TS_PHP_NAMESPACE_USE_CLAUSE = "namespace_use_clause"
+TS_PHP_INCLUDE_EXPRESSION = "include_expression"
+TS_PHP_INCLUDE_ONCE_EXPRESSION = "include_once_expression"
+TS_PHP_REQUIRE_EXPRESSION = "require_expression"
+TS_PHP_REQUIRE_ONCE_EXPRESSION = "require_once_expression"
+TS_PHP_ATTRIBUTE_LIST = "attribute_list"
+TS_PHP_ATTRIBUTE = "attribute"
+TS_PHP_ATTRIBUTE_GROUP = "attribute_group"
+TS_PHP_VISIBILITY_MODIFIER = "visibility_modifier"
+TS_PHP_USE_DECLARATION = "use_declaration"
+TS_PHP_QUALIFIED_NAME = "qualified_name"
# (H) Tree-sitter Lua node types for language_spec
TS_LUA_CHUNK = "chunk"
@@ -1739,11 +2081,15 @@ class CppNodeType(StrEnum):
TS_VIRTUAL = "virtual"
TS_TYPE_LIST = "type_list"
TS_CLASS_HERITAGE = "class_heritage"
+# (H) TS class `implements I, J` clause (a child of class_heritage).
+TS_IMPLEMENTS_CLAUSE = "implements_clause"
TS_EXTENDS_CLAUSE = "extends_clause"
TS_MEMBER_EXPRESSION = "member_expression"
TS_EXTENDS = "extends"
TS_ARGUMENTS = "arguments"
TS_EXTENDS_TYPE_CLAUSE = "extends_type_clause"
+# (H) Java interface `extends A, B` clause (tree-sitter-java); holds a type_list.
+TS_JAVA_EXTENDS_INTERFACES = "extends_interfaces"
TS_METHOD_DEFINITION = "method_definition"
TS_DECORATOR = "decorator"
TS_ERROR = "ERROR"
@@ -1827,6 +2173,20 @@ class CppNodeType(StrEnum):
}
)
+# (H) Java stdlib package prefixes for static stdlib detection
+JAVA_STDLIB_PREFIXES = (
+ "java.",
+ "javax.",
+ "jdk.",
+ "com.sun.",
+ "sun.",
+ "org.w3c.",
+ "org.xml.",
+ "org.ietf.",
+ "org.omg.",
+ "netscape.",
+)
+
# (H) Java common class names for heuristic detection
JAVA_STDLIB_CLASSES = frozenset(
{
@@ -1906,6 +2266,7 @@ class CppNodeType(StrEnum):
# (H) Tree-sitter field names for child_by_field_name
TS_FIELD_NAME = "name"
TS_FIELD_TYPE = "type"
+TS_SCOPED_TYPE_IDENTIFIER = "scoped_type_identifier"
TS_FIELD_SUPERCLASS = "superclass"
TS_FIELD_INTERFACES = "interfaces"
TS_FIELD_TYPE_PARAMETERS = "type_parameters"
@@ -2095,6 +2456,8 @@ class CppNodeType(StrEnum):
TS_PY_FOR_STATEMENT = "for_statement"
TS_PY_FOR_IN_CLAUSE = "for_in_clause"
TS_PY_ASSIGNMENT = "assignment"
+PY_ASSIGNMENT_QUERY = "(assignment) @assignment"
+PY_RETURN_QUERY = "(return_statement) @return_stmt"
TS_PY_CLASS_DEFINITION = "class_definition"
TS_PY_BLOCK = "block"
TS_PY_FUNCTION_DEFINITION = "function_definition"
@@ -2109,11 +2472,57 @@ class CppNodeType(StrEnum):
TS_PY_STRING = "string"
TS_PY_DECORATED_DEFINITION = "decorated_definition"
TS_PY_DECORATOR = "decorator"
+TS_PY_KEYWORD_ARGUMENT = "keyword_argument"
+TS_PY_DEFAULT_PARAMETER = "default_parameter"
+TS_PY_LIST_SPLAT_PATTERN = "list_splat_pattern"
+TS_PY_DICTIONARY_SPLAT_PATTERN = "dictionary_splat_pattern"
+TS_PY_SUBSCRIPT = "subscript"
+TS_PY_COMPARISON_OPERATOR = "comparison_operator"
+TS_FIELD_OPERATORS = "operators"
+TS_PY_IF_STATEMENT = "if_statement"
+TS_PY_WHILE_STATEMENT = "while_statement"
+TS_PY_ELIF_CLAUSE = "elif_clause"
+TS_PY_CONDITIONAL_EXPRESSION = "conditional_expression"
+TS_PY_BOOLEAN_OPERATOR = "boolean_operator"
+TS_PY_NOT_OPERATOR = "not_operator"
+TS_FIELD_CONDITION = "condition"
+TS_FIELD_ARGUMENT = "argument"
+
+# (H) Python operator syntax dispatches to dunder methods at runtime; these names
+# (H) let the call extractor synthesize the implied .__dunder__ call.
+PY_OP_IN = "in"
+PY_BUILTIN_LEN = "len"
+PY_BUILTIN_GETATTR = "getattr"
+TS_PY_STRING_CONTENT = "string_content"
+PY_DUNDER_GETITEM = "__getitem__"
+PY_DUNDER_SETITEM = "__setitem__"
+PY_DUNDER_CONTAINS = "__contains__"
+PY_DUNDER_LEN = "__len__"
+PY_DUNDER_BOOL = "__bool__"
+# (H) Operands with these characters are not simple attribute/name chains (calls,
+# (H) nested subscripts, whitespace), so the operator-dispatch synthesizer skips them.
+PY_OPERAND_REJECT_CHARS = "()[]{}\n\t "
+# (H) Optional annotation handling: X | None names a single concrete class.
+PY_UNION_SEPARATOR = "|"
+PY_NONE = "None"
# (H) Python keyword identifiers
PY_KEYWORD_SELF = "self"
PY_KEYWORD_CLS = "cls"
+# (H) typing.Protocol base name and the conventional XxxProtocol class suffix
+# (H) used to map a Protocol to its concrete implementer.
+PY_PROTOCOL = "Protocol"
PY_METHOD_INIT = "__init__"
+DECORATOR_AT = "@"
+PROPERTY_DECORATORS: frozenset[str] = frozenset({"property", "cached_property"})
+ABSTRACT_DECORATORS: frozenset[str] = frozenset({"abstractmethod", "abstractproperty"})
+
+# (H) Eager builtins that invoke a callable argument synchronously within the
+# (H) caller's own stack frame; a function passed to one is invoked there, so the
+# (H) trace attributes the call to the enclosing function (no Python frame exists
+# (H) for the builtin). Lazy higher-order builtins (map/filter) are excluded:
+# (H) they defer invocation until the result is consumed, which may be elsewhere.
+HIGHER_ORDER_BUILTINS: frozenset[str] = frozenset({"sorted", "min", "max", "reduce"})
# (H) Python attribute prefixes
PY_SELF_PREFIX = "self."
@@ -2134,8 +2543,9 @@ class CppNodeType(StrEnum):
TYPE_INFERENCE_LIST = "list"
TYPE_INFERENCE_BASE_MODEL = "BaseModel"
-# (H) Type inference guard attribute
+# (H) Recursion guard attributes
ATTR_TYPE_INFERENCE_IN_PROGRESS = "_type_inference_in_progress"
+GUARD_INHERITED_METHOD = "_inherited_method_guard"
# (H) JS/TS ingest node types
TS_PAIR = "pair"
@@ -2307,6 +2717,7 @@ class CppNodeType(StrEnum):
# (H) Tree-sitter Rust node types
TS_RS_SCOPED_TYPE_IDENTIFIER = "scoped_type_identifier"
+TS_RS_PRIMITIVE_TYPE = "primitive_type"
TS_RS_USE_AS_CLAUSE = "use_as_clause"
TS_RS_USE_WILDCARD = "use_wildcard"
TS_RS_USE_LIST = "use_list"
@@ -2355,12 +2766,21 @@ class MCPToolName(StrEnum):
DELETE_PROJECT = "delete_project"
WIPE_DATABASE = "wipe_database"
INDEX_REPOSITORY = "index_repository"
+ UPDATE_REPOSITORY = "update_repository"
QUERY_CODE_GRAPH = "query_code_graph"
GET_CODE_SNIPPET = "get_code_snippet"
SURGICAL_REPLACE_CODE = "surgical_replace_code"
READ_FILE = "read_file"
WRITE_FILE = "write_file"
LIST_DIRECTORY = "list_directory"
+ SEMANTIC_SEARCH = "semantic_search"
+ ASK_AGENT = "ask_agent"
+
+
+# (H) MCP transport selection
+class MCPTransport(StrEnum):
+ STDIO = "stdio"
+ HTTP = "http"
# (H) MCP environment variables
@@ -2400,6 +2820,8 @@ class MCPParamName(StrEnum):
LIMIT = "limit"
CONTENT = "content"
DIRECTORY_PATH = "directory_path"
+ TOP_K = "top_k"
+ QUESTION = "question"
# (H) MCP server constants
@@ -2418,6 +2840,12 @@ class MCPParamName(StrEnum):
MCP_WRITE_SUCCESS = "Successfully wrote file: {path}"
MCP_UNKNOWN_TOOL_ERROR = "Unknown tool: {name}"
MCP_TOOL_EXEC_ERROR = "Error executing tool '{name}': {error}"
+MCP_UPDATE_SUCCESS = "Successfully updated repository at {path} (no database wipe)."
+MCP_UPDATE_ERROR = "Error updating repository: {error}"
+MCP_SEMANTIC_NOT_AVAILABLE_RESPONSE = (
+ "Semantic search is not available. Install with: uv sync --extra semantic"
+)
+MCP_ASK_AGENT_ERROR = "Error running ask_agent: {error}"
MCP_PROJECT_DELETED = "Successfully deleted project '{project_name}'."
MCP_WIPE_CANCELLED = "Database wipe cancelled. Set confirm=true to proceed."
MCP_WIPE_SUCCESS = "Database completely wiped. All projects have been removed."
@@ -2460,11 +2888,14 @@ class MCPParamName(StrEnum):
TS_FUNCTION_EXPRESSION,
)
-# (H) FQN node type tuples for TS
+# (H) FQN node type tuples for TS. The grammar emits `internal_module` for a
+# (H) `namespace`/`module` block; without it a class declared inside a namespace
+# (H) loses the namespace from its qn and collides with a top-level same name.
FQN_TS_SCOPE_TYPES = (
TS_CLASS_DECLARATION,
TS_INTERFACE_DECLARATION,
TS_NAMESPACE_DEFINITION,
+ TS_INTERNAL_MODULE,
TS_PROGRAM,
TS_FUNCTION_DECLARATION,
TS_FUNCTION_EXPRESSION,
@@ -2550,35 +2981,19 @@ class MCPParamName(StrEnum):
TS_SCALA_FUNCTION_DECLARATION,
)
-# (H) FQN node type tuples for C#
-FQN_CS_SCOPE_TYPES = (
- TS_CLASS_DECLARATION,
- TS_CS_STRUCT_DECLARATION,
- TS_INTERFACE_DECLARATION,
- TS_CS_COMPILATION_UNIT,
-)
-FQN_CS_FUNCTION_TYPES = (
- TS_CS_DESTRUCTOR_DECLARATION,
- TS_CS_LOCAL_FUNCTION_STATEMENT,
- TS_CS_FUNCTION_POINTER_TYPE,
- TS_CONSTRUCTOR_DECLARATION,
- TS_CS_ANONYMOUS_METHOD_EXPRESSION,
- TS_CS_LAMBDA_EXPRESSION,
- TS_METHOD_DECLARATION,
-)
-
# (H) FQN node type tuples for PHP
FQN_PHP_SCOPE_TYPES = (
TS_CLASS_DECLARATION,
TS_INTERFACE_DECLARATION,
TS_PHP_TRAIT_DECLARATION,
+ TS_PHP_NAMESPACE_DEFINITION,
TS_PROGRAM,
)
FQN_PHP_FUNCTION_TYPES = (
- TS_PY_FUNCTION_DEFINITION,
+ TS_PHP_FUNCTION_DEFINITION,
+ TS_PHP_METHOD_DECLARATION,
TS_PHP_ANONYMOUS_FUNCTION,
TS_PHP_ARROW_FUNCTION,
- TS_PHP_FUNCTION_STATIC_DECLARATION,
)
# (H) LANGUAGE_SPECS node type tuples for Python
@@ -2599,6 +3014,8 @@ class MCPParamName(StrEnum):
TS_FUNCTION_DECLARATION,
TS_CLASS_DECLARATION,
TS_METHOD_DEFINITION,
+ # (H) TS `namespace`/`module` block; its `name` field scopes nested classes.
+ TS_INTERNAL_MODULE,
)
# (H) Derived node types for _rust_get_name
@@ -2617,6 +3034,13 @@ class MCPParamName(StrEnum):
TS_ENUM_SPECIFIER,
)
+# (H) Derived node types for _c_get_name
+C_NAME_NODE_TYPES = (
+ TS_STRUCT_SPECIFIER,
+ TS_UNION_SPECIFIER,
+ TS_ENUM_SPECIFIER,
+)
+
# (H) LANGUAGE_SPECS node type tuples for Rust
SPEC_RS_FUNCTION_TYPES = (
TS_RS_FUNCTION_ITEM,
@@ -2639,7 +3063,7 @@ class MCPParamName(StrEnum):
# (H) LANGUAGE_SPECS node type tuples for Go
SPEC_GO_FUNCTION_TYPES = (TS_GO_FUNCTION_DECLARATION, TS_GO_METHOD_DECLARATION)
-SPEC_GO_CLASS_TYPES = (TS_GO_TYPE_DECLARATION,)
+SPEC_GO_CLASS_TYPES = (TS_GO_TYPE_SPEC, TS_GO_TYPE_ALIAS)
SPEC_GO_MODULE_TYPES = (TS_GO_SOURCE_FILE,)
SPEC_GO_CALL_TYPES = (TS_GO_CALL_EXPRESSION,)
SPEC_GO_IMPORT_TYPES = (TS_GO_IMPORT_DECLARATION,)
@@ -2713,44 +3137,53 @@ class MCPParamName(StrEnum):
PKG_CONANFILE,
)
-# (H) LANGUAGE_SPECS node type tuples for C#
-SPEC_CS_FUNCTION_TYPES = (
- TS_CS_DESTRUCTOR_DECLARATION,
- TS_CS_LOCAL_FUNCTION_STATEMENT,
- TS_CS_FUNCTION_POINTER_TYPE,
- TS_CONSTRUCTOR_DECLARATION,
- TS_CS_ANONYMOUS_METHOD_EXPRESSION,
- TS_CS_LAMBDA_EXPRESSION,
- TS_METHOD_DECLARATION,
+# (H) FQN node type tuples for C
+FQN_C_SCOPE_TYPES = (
+ TS_CPP_TRANSLATION_UNIT,
+ TS_STRUCT_SPECIFIER,
+ TS_UNION_SPECIFIER,
+ TS_ENUM_SPECIFIER,
)
-SPEC_CS_CLASS_TYPES = (
- TS_CLASS_DECLARATION,
- TS_CS_STRUCT_DECLARATION,
- TS_ENUM_DECLARATION,
- TS_INTERFACE_DECLARATION,
+FQN_C_FUNCTION_TYPES = (TS_CPP_FUNCTION_DEFINITION,)
+
+# (H) LANGUAGE_SPECS node type tuples for C
+SPEC_C_FUNCTION_TYPES = (TS_CPP_FUNCTION_DEFINITION,)
+SPEC_C_CLASS_TYPES = (
+ TS_STRUCT_SPECIFIER,
+ TS_UNION_SPECIFIER,
+ TS_ENUM_SPECIFIER,
)
-SPEC_CS_MODULE_TYPES = (TS_CS_COMPILATION_UNIT,)
-SPEC_CS_CALL_TYPES = (TS_CS_INVOCATION_EXPRESSION,)
+SPEC_C_MODULE_TYPES = (TS_CPP_TRANSLATION_UNIT,)
+SPEC_C_CALL_TYPES = (TS_CPP_CALL_EXPRESSION,)
+SPEC_C_PACKAGE_INDICATORS = (PKG_CMAKE_LISTS, PKG_MAKEFILE)
# (H) LANGUAGE_SPECS node type tuples for PHP
SPEC_PHP_FUNCTION_TYPES = (
- TS_PHP_FUNCTION_STATIC_DECLARATION,
+ TS_PHP_FUNCTION_DEFINITION,
+ TS_PHP_METHOD_DECLARATION,
TS_PHP_ANONYMOUS_FUNCTION,
- TS_PY_FUNCTION_DEFINITION,
TS_PHP_ARROW_FUNCTION,
)
SPEC_PHP_CLASS_TYPES = (
+ TS_CLASS_DECLARATION,
+ TS_INTERFACE_DECLARATION,
TS_PHP_TRAIT_DECLARATION,
TS_ENUM_DECLARATION,
- TS_INTERFACE_DECLARATION,
- TS_CLASS_DECLARATION,
)
SPEC_PHP_MODULE_TYPES = (TS_PROGRAM,)
SPEC_PHP_CALL_TYPES = (
+ TS_PHP_FUNCTION_CALL_EXPRESSION,
TS_PHP_MEMBER_CALL_EXPRESSION,
TS_PHP_SCOPED_CALL_EXPRESSION,
- TS_PHP_FUNCTION_CALL_EXPRESSION,
TS_PHP_NULLSAFE_MEMBER_CALL_EXPRESSION,
+ TS_PHP_OBJECT_CREATION_EXPRESSION,
+)
+SPEC_PHP_IMPORT_TYPES = (TS_PHP_NAMESPACE_USE_DECLARATION,)
+SPEC_PHP_IMPORT_FROM_TYPES = (
+ TS_PHP_INCLUDE_EXPRESSION,
+ TS_PHP_INCLUDE_ONCE_EXPRESSION,
+ TS_PHP_REQUIRE_EXPRESSION,
+ TS_PHP_REQUIRE_ONCE_EXPRESSION,
)
# (H) LANGUAGE_SPECS node type tuples for Lua
diff --git a/codebase_rag/cypher_queries.py b/codebase_rag/cypher_queries.py
index 8d70bae4e..cf06641d7 100644
--- a/codebase_rag/cypher_queries.py
+++ b/codebase_rag/cypher_queries.py
@@ -52,8 +52,8 @@
CYPHER_EXAMPLE_LIMIT_ONE = """MATCH (f:File) RETURN f.path as path, f.name as name, labels(f) as type LIMIT 1"""
CYPHER_EXAMPLE_CLASS_METHODS = f"""MATCH (c:Class)-[:DEFINES_METHOD]->(m:Method)
-WHERE c.qualified_name ENDS WITH '.UserService'
-RETURN m.name AS name, m.qualified_name AS qualified_name, labels(m) AS type
+WHERE c.name = 'UserService'
+RETURN c.name AS className, m.name AS methodName, m.qualified_name AS qualified_name, labels(m) AS type
LIMIT {CYPHER_DEFAULT_LIMIT}"""
CYPHER_EXPORT_NODES = """
@@ -84,6 +84,90 @@
"""
+CYPHER_STATS_NODE_COUNTS = """
+MATCH (n)
+RETURN labels(n) AS labels, count(*) AS count
+ORDER BY count DESC
+"""
+
+CYPHER_STATS_RELATIONSHIP_COUNTS = """
+MATCH ()-[r]->()
+RETURN type(r) AS type, count(*) AS count
+ORDER BY count DESC
+"""
+
+
+_DEAD_CODE_TEST_ROOT_CLAUSE = (
+ "\n OR ANY(p IN $test_patterns WHERE n.path CONTAINS p)"
+)
+
+# (H) A node reached by a Module node runs at import (top-level statement,
+# (H) `if __name__ == "__main__"`, a bare decorator, or a module-scope
+# (H) construction), so it is a root. `size([...])` avoids the non-standard
+# (H) `exists(pattern)`. When tests are excluded, an edge from a test module must
+# (H) NOT keep project code alive, so the test-module variant filters by path.
+# (H) `{module_rels}` is the relationship set walked from the module (CALLS, plus
+# (H) INSTANTIATES when classes are included so module-scope construction roots a
+# (H) class).
+_DEAD_CODE_MODULE_ROOT_ANY = "size([(n)<-[:{module_rels}]-(:Module) | 1]) > 0"
+_DEAD_CODE_MODULE_ROOT_NON_TEST = (
+ "size([(n)<-[:{module_rels}]-(m:Module)"
+ " WHERE NOT ANY(p IN $test_patterns WHERE m.path CONTAINS p) | 1]) > 0"
+)
+
+# (H) Reachability walks CALLS only by default. With classes included it also
+# (H) walks INSTANTIATES (construction keeps a class live) and INHERITS forward
+# (H) from subclass to base, so a base is kept live only by a REACHABLE subclass.
+# (H) A base whose sole subclass is itself unreachable is therefore reported as
+# (H) part of the dead cluster (the subclass is reported too). Classes referenced
+# (H) solely via type annotations / isinstance / dynamic lookups are not modelled
+# (H) as edges, so class candidates are review hints, not a delete list.
+_DEAD_CODE_QUERY_TEMPLATE = """MATCH (n:{labels})
+WHERE n.qualified_name STARTS WITH $project_prefix
+ AND (
+ ANY(d IN n.decorators
+ WHERE toLower(last(split(split(replace(d, '@', ''), '(')[0], '.')))
+ IN $root_decorators)
+ OR n.is_exported = true
+ OR ANY(e IN $entry_points WHERE n.qualified_name ENDS WITH e)
+ OR {module_clause}{test_clause}
+ )
+WITH collect(n) AS roots
+UNWIND roots AS r
+MATCH (r)-[:{traversal}*0..]->(live)
+WITH collect(DISTINCT live) AS live_set
+MATCH (n:{labels})
+WHERE n.qualified_name STARTS WITH $project_prefix
+ AND NOT n IN live_set
+RETURN labels(n)[0] AS label, n.name AS name,
+ n.qualified_name AS qualified_name,
+ n.start_line AS start_line, n.end_line AS end_line
+ORDER BY qualified_name"""
+
+
+def build_dead_code_query(include_tests: bool, include_classes: bool = False) -> str:
+ if include_classes:
+ labels = "Function|Method|Class"
+ traversal = "CALLS|INSTANTIATES|INHERITS"
+ module_rels = "CALLS|INSTANTIATES"
+ else:
+ labels = "Function|Method"
+ traversal = "CALLS"
+ module_rels = "CALLS"
+ if include_tests:
+ module_clause = _DEAD_CODE_MODULE_ROOT_ANY.format(module_rels=module_rels)
+ test_clause = _DEAD_CODE_TEST_ROOT_CLAUSE
+ else:
+ module_clause = _DEAD_CODE_MODULE_ROOT_NON_TEST.format(module_rels=module_rels)
+ test_clause = ""
+ return _DEAD_CODE_QUERY_TEMPLATE.format(
+ labels=labels,
+ traversal=traversal,
+ module_clause=module_clause,
+ test_clause=test_clause,
+ )
+
+
def wrap_with_unwind(query: str) -> str:
return f"UNWIND $batch AS row\n{query}"
@@ -126,3 +210,24 @@ def build_merge_relationship_query(
)
query += CYPHER_SET_PROPS_RETURN_COUNT if has_props else CYPHER_RETURN_COUNT
return query
+
+
+def build_create_node_query(label: str, id_key: str) -> str:
+ return f"CREATE (n:{label} {{{id_key}: row.id}})\nSET n += row.props"
+
+
+def build_create_relationship_query(
+ from_label: str,
+ from_key: str,
+ rel_type: str,
+ to_label: str,
+ to_key: str,
+ has_props: bool = False,
+) -> str:
+ query = (
+ f"MATCH (a:{from_label} {{{from_key}: row.from_val}}), "
+ f"(b:{to_label} {{{to_key}: row.to_val}})\n"
+ f"CREATE (a)-[r:{rel_type}]->(b)\n"
+ )
+ query += CYPHER_SET_PROPS_RETURN_COUNT if has_props else CYPHER_RETURN_COUNT
+ return query
diff --git a/codebase_rag/docker-compose.yaml b/codebase_rag/docker-compose.yaml
new file mode 100644
index 000000000..1b394c873
--- /dev/null
+++ b/codebase_rag/docker-compose.yaml
@@ -0,0 +1,27 @@
+services:
+ memgraph:
+ image: memgraph/memgraph-mage
+ ports:
+ - "${MEMGRAPH_PORT:-7687}:7687"
+ - "${MEMGRAPH_HTTP_PORT:-7444}:7444"
+ volumes:
+ - memgraph_data:/var/lib/memgraph
+ - memgraph_log:/var/log/memgraph
+ lab:
+ image: memgraph/lab
+ ports:
+ - "${LAB_PORT:-3000}:3000"
+ environment:
+ QUICK_CONNECT_MG_HOST: memgraph
+ qdrant:
+ image: qdrant/qdrant
+ ports:
+ - "${QDRANT_HTTP_PORT:-6333}:6333"
+ - "${QDRANT_GRPC_PORT:-6334}:6334"
+ volumes:
+ - qdrant_storage:/qdrant/storage
+
+volumes:
+ qdrant_storage:
+ memgraph_data:
+ memgraph_log:
diff --git a/codebase_rag/embedder.py b/codebase_rag/embedder.py
index 0928cae97..89b3b466f 100644
--- a/codebase_rag/embedder.py
+++ b/codebase_rag/embedder.py
@@ -1,19 +1,96 @@
-# ┌────────────────────────────────────────────────────────────────────────┐
-# │ UniXcoder Model Singleton via LRU Cache │
-# ├────────────────────────────────────────────────────────────────────────┤
-# │ get_model() provides: │
-# │ - Singleton behavior without global variables │
-# │ - Thread-safe lazy initialization │
-# │ - Easy testability with cache_clear() method │
-# │ - Memory efficient with maxsize=1 │
-# └────────────────────────────────────────────────────────────────────────┘
+from __future__ import annotations
+
+import hashlib
+import json
from functools import lru_cache
+from pathlib import Path
+
+from loguru import logger
+from . import constants as cs
from . import exceptions as ex
+from . import logs as ls
from .config import settings
-from .constants import UNIXCODER_MODEL
from .utils.dependencies import has_torch, has_transformers
+
+class EmbeddingCache:
+ __slots__ = ("_cache", "_path")
+
+ def __init__(self, path: Path | None = None) -> None:
+ self._cache: dict[str, list[float]] = {}
+ self._path = path
+
+ @staticmethod
+ def _content_hash(content: str) -> str:
+ return hashlib.sha256(content.encode()).hexdigest()
+
+ def get(self, content: str) -> list[float] | None:
+ return self._cache.get(self._content_hash(content))
+
+ def put(self, content: str, embedding: list[float]) -> None:
+ self._cache[self._content_hash(content)] = embedding
+
+ def get_many(self, snippets: list[str]) -> dict[int, list[float]]:
+ results: dict[int, list[float]] = {}
+ for i, snippet in enumerate(snippets):
+ if (cached := self.get(snippet)) is not None:
+ results[i] = cached
+ return results
+
+ def put_many(self, snippets: list[str], embeddings: list[list[float]]) -> None:
+ for snippet, embedding in zip(snippets, embeddings):
+ self.put(snippet, embedding)
+
+ def save(self) -> None:
+ if self._path is None:
+ return
+ try:
+ self._path.parent.mkdir(parents=True, exist_ok=True)
+ with self._path.open("w", encoding="utf-8") as f:
+ json.dump(self._cache, f)
+ except Exception as e:
+ logger.warning(ls.EMBEDDING_CACHE_SAVE_FAILED, path=self._path, error=e)
+
+ def load(self) -> None:
+ if self._path is None or not self._path.exists():
+ return
+ try:
+ with self._path.open("r", encoding="utf-8") as f:
+ self._cache = json.load(f)
+ logger.debug(
+ ls.EMBEDDING_CACHE_LOADED, count=len(self._cache), path=self._path
+ )
+ except Exception as e:
+ logger.warning(ls.EMBEDDING_CACHE_LOAD_FAILED, path=self._path, error=e)
+ self._cache = {}
+
+ def clear(self) -> None:
+ self._cache.clear()
+
+ def __len__(self) -> int:
+ return len(self._cache)
+
+
+_embedding_cache: EmbeddingCache | None = None
+
+
+def get_embedding_cache() -> EmbeddingCache:
+ global _embedding_cache
+ if _embedding_cache is None:
+ cache_path = Path(settings.QDRANT_DB_PATH) / cs.EMBEDDING_CACHE_FILENAME
+ _embedding_cache = EmbeddingCache(path=cache_path)
+ _embedding_cache.load()
+ return _embedding_cache
+
+
+def clear_embedding_cache() -> None:
+ global _embedding_cache
+ if _embedding_cache is not None:
+ _embedding_cache.clear()
+ _embedding_cache = None
+
+
if has_torch() and has_transformers():
import numpy as np
import torch
@@ -21,15 +98,29 @@
from .unixcoder import UniXcoder
+ def _select_device() -> str:
+ if torch.cuda.is_available():
+ return "cuda"
+ if torch.backends.mps.is_available():
+ return "mps"
+ return "cpu"
+
@lru_cache(maxsize=1)
def get_model() -> UniXcoder:
- model = UniXcoder(UNIXCODER_MODEL)
+ model = UniXcoder(cs.UNIXCODER_MODEL)
model.eval()
- if torch.cuda.is_available():
+ device = _select_device()
+ if device == "cuda":
model = model.cuda()
+ elif device == "mps":
+ model = model.to("mps")
return model
def embed_code(code: str, max_length: int | None = None) -> list[float]:
+ cache = get_embedding_cache()
+ if (cached := cache.get(code)) is not None:
+ return cached
+
if max_length is None:
max_length = settings.EMBEDDING_MAX_LENGTH
model = get_model()
@@ -40,9 +131,63 @@ def embed_code(code: str, max_length: int | None = None) -> list[float]:
_, sentence_embeddings = model(tokens_tensor)
embedding: NDArray[np.float32] = sentence_embeddings.cpu().numpy()
result: list[float] = embedding[0].tolist()
+
+ cache.put(code, result)
return result
+ def embed_code_batch(
+ snippets: list[str],
+ max_length: int | None = None,
+ batch_size: int = cs.EMBEDDING_DEFAULT_BATCH_SIZE,
+ ) -> list[list[float]]:
+ if not snippets:
+ return []
+
+ if max_length is None:
+ max_length = settings.EMBEDDING_MAX_LENGTH
+
+ cache = get_embedding_cache()
+ cached_results = cache.get_many(snippets)
+
+ if len(cached_results) == len(snippets):
+ logger.debug(ls.EMBEDDING_CACHE_HIT, count=len(snippets))
+ return [cached_results[i] for i in range(len(snippets))]
+
+ uncached_indices = [i for i in range(len(snippets)) if i not in cached_results]
+ uncached_snippets = [snippets[i] for i in uncached_indices]
+
+ model = get_model()
+ device = next(model.parameters()).device
+
+ all_new_embeddings: list[list[float]] = []
+ for start in range(0, len(uncached_snippets), batch_size):
+ batch = uncached_snippets[start : start + batch_size]
+ tokens_list = model.tokenize(batch, max_length=max_length, padding=True)
+ tokens_tensor = torch.tensor(tokens_list).to(device)
+ with torch.no_grad():
+ _, sentence_embeddings = model(tokens_tensor)
+ batch_np: NDArray[np.float32] = sentence_embeddings.cpu().numpy()
+ for row in batch_np:
+ all_new_embeddings.append(row.tolist())
+
+ cache.put_many(uncached_snippets, all_new_embeddings)
+
+ results: list[list[float]] = [[] for _ in snippets]
+ for i, emb in cached_results.items():
+ results[i] = emb
+ for idx, orig_i in enumerate(uncached_indices):
+ results[orig_i] = all_new_embeddings[idx]
+
+ return results
+
else:
def embed_code(code: str, max_length: int | None = None) -> list[float]:
raise RuntimeError(ex.SEMANTIC_EXTRA)
+
+ def embed_code_batch(
+ snippets: list[str],
+ max_length: int | None = None,
+ batch_size: int = cs.EMBEDDING_DEFAULT_BATCH_SIZE,
+ ) -> list[list[float]]:
+ raise RuntimeError(ex.SEMANTIC_EXTRA)
diff --git a/codebase_rag/exceptions.py b/codebase_rag/exceptions.py
index f30202395..21c479995 100644
--- a/codebase_rag/exceptions.py
+++ b/codebase_rag/exceptions.py
@@ -11,10 +11,26 @@
"OpenAI provider requires api_key. "
"Set ORCHESTRATOR_API_KEY or CYPHER_API_KEY in .env file."
)
+ANTHROPIC_NO_KEY = (
+ "Anthropic provider requires api_key. "
+ "Set ORCHESTRATOR_API_KEY or CYPHER_API_KEY in .env file."
+)
+AZURE_NO_KEY = "Azure OpenAI provider requires api_key. Set AZURE_API_KEY in .env file."
+AZURE_NO_ENDPOINT = (
+ "Azure OpenAI provider requires endpoint. Set AZURE_OPENAI_ENDPOINT in .env file."
+)
OLLAMA_NOT_RUNNING = (
"Ollama server not responding at {endpoint}. "
"Make sure Ollama is running: ollama serve"
)
+LITELLM_NO_ENDPOINT = (
+ "LiteLLM provider requires endpoint. "
+ "Set ORCHESTRATOR_ENDPOINT or CYPHER_ENDPOINT in .env file."
+)
+LITELLM_NOT_RUNNING = (
+ "LiteLLM proxy server not responding at {endpoint}. "
+ "Make sure LiteLLM proxy is running and API key is valid."
+)
UNKNOWN_PROVIDER = "Unknown provider '{provider}'. Available providers: {available}"
# (H) Dependency errors
@@ -42,16 +58,29 @@
# (H) LLM errors
LLM_INIT_CYPHER = "Failed to initialize CypherGenerator: {error}"
LLM_INVALID_QUERY = "LLM did not generate a valid query. Output: {output}"
+LLM_DANGEROUS_QUERY = "LLM generated a destructive Cypher query (found '{keyword}'). Query rejected: {query}"
+LLM_UNBOUNDED_PATH = (
+ "LLM generated an unbounded variable-length path pattern "
+ "(e.g. [:TYPE*] or [:TYPE*N..]) which causes memory exhaustion on cyclic graphs. "
+ "Add an upper bound such as [:TYPE*1..6]. Query rejected: {query}"
+)
+LLM_DISALLOWED_PROCEDURE = (
+ "LLM generated a CALL to procedure '{name}' which is outside the read-only "
+ "MAGE allowlist. Query rejected: {query}"
+)
LLM_GENERATION_FAILED = "Cypher generation failed: {error}"
LLM_INIT_ORCHESTRATOR = "Failed to initialize RAG Orchestrator: {error}"
# (H) Graph service errors
BATCH_SIZE = "batch_size must be a positive integer"
CONN = "Not connected to Memgraph."
+AUTH_INCOMPLETE = (
+ "Both username and password are required for authentication. "
+ "Either provide both or neither."
+)
# (H) Access control errors (used with raise)
ACCESS_DENIED = "Access denied: Cannot access files outside the project root."
-DOC_UNSUPPORTED_PROVIDER = "DocumentAnalyzer does not support the 'local' LLM provider."
# (H) Exception classes
diff --git a/codebase_rag/graph_loader.py b/codebase_rag/graph_loader.py
index b69635755..6a210c6d5 100644
--- a/codebase_rag/graph_loader.py
+++ b/codebase_rag/graph_loader.py
@@ -13,6 +13,18 @@
class GraphLoader:
+ __slots__ = (
+ "file_path",
+ "_data",
+ "_nodes",
+ "_relationships",
+ "_nodes_by_id",
+ "_nodes_by_label",
+ "_outgoing_rels",
+ "_incoming_rels",
+ "_property_indexes",
+ )
+
def __init__(self, file_path: str):
self.file_path = Path(file_path)
self._data: GraphData | None = None
diff --git a/codebase_rag/graph_updater.py b/codebase_rag/graph_updater.py
index 2620d2bcb..442471c24 100644
--- a/codebase_rag/graph_updater.py
+++ b/codebase_rag/graph_updater.py
@@ -1,16 +1,27 @@
+import hashlib
+import json
+import os
import sys
from collections import OrderedDict, defaultdict
from collections.abc import Callable, ItemsView, KeysView
from pathlib import Path
from loguru import logger
-from tree_sitter import Node, Parser
+from rich.progress import Progress, SpinnerColumn, TextColumn
+from tree_sitter import Node, Parser, QueryCursor
from . import constants as cs
from . import logs as ls
from .config import settings
from .language_spec import LANGUAGE_FQN_SPECS, get_language_spec
+from .parser_loader import COMBINED_FUNC_CLASS_IMPORT_QUERIES
+from .parsers.cpp_frontend import (
+ cpp_frontend_available,
+ find_compile_commands,
+ run_cpp_frontend,
+)
from .parsers.factory import ProcessorFactory
+from .parsers.utils import sorted_captures
from .services import IngestorProtocol, QueryProtocol
from .types_defs import (
EmbeddingQueryResult,
@@ -24,19 +35,90 @@
)
from .utils.dependencies import has_semantic_dependencies
from .utils.fqn_resolver import find_function_source_by_fqn
-from .utils.path_utils import should_skip_path
+from .utils.path_utils import (
+ cached_relative_path,
+ should_skip_path,
+ should_skip_rel_file,
+)
from .utils.source_extraction import extract_source_with_fallback
+type FileHashCache = dict[str, str]
+type DirMtimesCache = dict[str, float]
+
class FunctionRegistryTrie:
+ __slots__ = (
+ "root",
+ "_entries",
+ "_simple_name_lookup",
+ "_ending_with_cache",
+ "_duplicates",
+ "_properties",
+ "_property_names",
+ "_abstracts",
+ "_callable_params",
+ )
+
def __init__(self, simple_name_lookup: SimpleNameLookup | None = None) -> None:
self.root: TrieNode = {}
self._entries: FunctionRegistry = {}
self._simple_name_lookup = simple_name_lookup
+ self._ending_with_cache: dict[str, list[QualifiedName]] = {}
+ self._duplicates: dict[QualifiedName, list[QualifiedName]] = {}
+ self._properties: set[QualifiedName] = set()
+ self._property_names: set[str] = set()
+ self._abstracts: set[QualifiedName] = set()
+ self._callable_params: dict[QualifiedName, dict[str, int]] = {}
+
+ def mark_callable_params(
+ self, qualified_name: QualifiedName, params: dict[str, int]
+ ) -> None:
+ if params:
+ self._callable_params[qualified_name] = params
+
+ def callable_params(self, qualified_name: QualifiedName) -> dict[str, int] | None:
+ return self._callable_params.get(qualified_name)
+
+ def mark_property(self, qualified_name: QualifiedName) -> None:
+ self._properties.add(qualified_name)
+ self._property_names.add(qualified_name.rsplit(cs.SEPARATOR_DOT, 1)[-1])
+
+ def is_property(self, qualified_name: QualifiedName) -> bool:
+ return qualified_name in self._properties
+
+ def property_names(self) -> set[str]:
+ return self._property_names
+
+ def mark_abstract(self, qualified_name: QualifiedName) -> None:
+ self._abstracts.add(qualified_name)
+
+ def is_abstract(self, qualified_name: QualifiedName) -> bool:
+ return qualified_name in self._abstracts
+
+ def register_unique_qn(
+ self, natural_qn: QualifiedName, start_line: int
+ ) -> QualifiedName:
+ if natural_qn not in self._entries:
+ return natural_qn
+ variant = f"{natural_qn}{cs.DUP_QN_MARKER}{start_line}"
+ bucket = self._duplicates.setdefault(natural_qn, [natural_qn])
+ if variant not in bucket:
+ bucket.append(variant)
+ return variant
+
+ def variants(self, qualified_name: QualifiedName) -> list[QualifiedName]:
+ return self._duplicates.get(qualified_name, [qualified_name])
def insert(self, qualified_name: QualifiedName, func_type: NodeType) -> None:
+ qualified_name = sys.intern(qualified_name)
self._entries[qualified_name] = func_type
+ simple_name = qualified_name.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+ if self._simple_name_lookup is not None:
+ self._simple_name_lookup[simple_name].add(qualified_name)
+ if self._ending_with_cache:
+ self._ending_with_cache.pop(simple_name, None)
+
parts = qualified_name.split(cs.SEPARATOR_DOT)
current: TrieNode = self.root
@@ -69,6 +151,30 @@ def __delitem__(self, qualified_name: QualifiedName) -> None:
return
del self._entries[qualified_name]
+ self._duplicates.pop(qualified_name, None)
+ for natural, bucket in list(self._duplicates.items()):
+ if qualified_name in bucket:
+ bucket.remove(qualified_name)
+ if len(bucket) <= 1:
+ self._duplicates.pop(natural, None)
+ simple_name = qualified_name.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+
+ if qualified_name in self._properties:
+ self._properties.discard(qualified_name)
+ if not any(
+ p.rsplit(cs.SEPARATOR_DOT, 1)[-1] == simple_name
+ for p in self._properties
+ ):
+ self._property_names.discard(simple_name)
+ self._abstracts.discard(qualified_name)
+ self._callable_params.pop(qualified_name, None)
+
+ if self._ending_with_cache:
+ self._ending_with_cache.pop(simple_name, None)
+
+ if self._simple_name_lookup is not None:
+ if simple_name in self._simple_name_lookup:
+ self._simple_name_lookup[simple_name].discard(qualified_name)
parts = qualified_name.split(cs.SEPARATOR_DOT)
self._cleanup_trie_path(parts, self.root)
@@ -148,11 +254,20 @@ def find_with_prefix_and_suffix(
return [qn for qn, _ in matches]
def find_ending_with(self, suffix: str) -> list[QualifiedName]:
- if self._simple_name_lookup is not None and suffix in self._simple_name_lookup:
- # (H) O(1) lookup using the simple_name_lookup index
- return list(self._simple_name_lookup[suffix])
- # (H) Fallback to linear scan if no index available
- return [qn for qn in self._entries.keys() if qn.endswith(f".{suffix}")]
+ cached = self._ending_with_cache.get(suffix)
+ if cached is not None:
+ return cached
+ if self._simple_name_lookup is not None:
+ if suffix in self._simple_name_lookup:
+ result = sorted(self._simple_name_lookup[suffix])
+ else:
+ result = []
+ else:
+ result = sorted(
+ qn for qn in self._entries.keys() if qn.endswith(f".{suffix}")
+ )
+ self._ending_with_cache[suffix] = result
+ return result
def find_with_prefix(self, prefix: str) -> list[tuple[QualifiedName, NodeType]]:
node = self._navigate_to_prefix(prefix)
@@ -160,6 +275,8 @@ def find_with_prefix(self, prefix: str) -> list[tuple[QualifiedName, NodeType]]:
class BoundedASTCache:
+ __slots__ = ("cache", "max_entries", "max_memory_bytes")
+
def __init__(
self,
max_entries: int | None = None,
@@ -220,6 +337,78 @@ def _should_evict_for_memory(self) -> bool:
)
+def _hash_file(filepath: Path) -> str:
+ data = filepath.read_bytes()
+ return hashlib.md5(data, usedforsecurity=False).hexdigest()
+
+
+def _hash_file_with_bytes(filepath: Path) -> tuple[str, bytes] | None:
+ try:
+ with open(filepath, "rb") as f:
+ data = f.read()
+ except OSError as e:
+ logger.warning(ls.FILE_UNREADABLE, path=filepath, error=e)
+ return None
+ return hashlib.md5(data, usedforsecurity=False).hexdigest(), data
+
+
+def _load_hash_cache(cache_path: Path) -> FileHashCache:
+ if not cache_path.is_file():
+ return {}
+ try:
+ with cache_path.open(encoding="utf-8") as f:
+ data = json.load(f)
+ if isinstance(data, dict):
+ logger.info(ls.HASH_CACHE_LOADED, count=len(data), path=cache_path)
+ return data
+ except (json.JSONDecodeError, OSError) as e:
+ logger.warning(ls.HASH_CACHE_LOAD_FAILED, path=cache_path, error=e)
+ return {}
+
+
+def _save_hash_cache(cache_path: Path, hashes: FileHashCache) -> None:
+ try:
+ cache_path.parent.mkdir(parents=True, exist_ok=True)
+ with cache_path.open("w", encoding="utf-8") as f:
+ json.dump(hashes, f, indent=2)
+ logger.info(ls.HASH_CACHE_SAVED, count=len(hashes), path=cache_path)
+ except OSError as e:
+ logger.warning(ls.HASH_CACHE_SAVE_FAILED, path=cache_path, error=e)
+
+
+def _load_dir_mtimes(cache_path: Path) -> DirMtimesCache:
+ if not cache_path.is_file():
+ return {}
+ try:
+ with cache_path.open(encoding="utf-8") as f:
+ data = json.load(f)
+ if isinstance(data, dict):
+ return {k: float(v) for k, v in data.items() if isinstance(v, int | float)}
+ except (json.JSONDecodeError, OSError, ValueError):
+ pass
+ return {}
+
+
+def _save_dir_mtimes(cache_path: Path, mtimes: DirMtimesCache) -> None:
+ try:
+ cache_path.parent.mkdir(parents=True, exist_ok=True)
+ with cache_path.open("w", encoding="utf-8") as f:
+ json.dump(mtimes, f)
+ except OSError:
+ pass
+
+
+def _touch_empty_json(cache_path: Path) -> None:
+ if cache_path.exists():
+ return
+ try:
+ cache_path.parent.mkdir(parents=True, exist_ok=True)
+ with cache_path.open("w", encoding="utf-8") as f:
+ f.write(cs.JSON_EMPTY_OBJECT)
+ except OSError:
+ pass
+
+
class GraphUpdater:
def __init__(
self,
@@ -229,12 +418,20 @@ def __init__(
queries: dict[cs.SupportedLanguage, LanguageQueries],
unignore_paths: frozenset[str] | None = None,
exclude_paths: frozenset[str] | None = None,
+ project_name: str | None = None,
):
self.ingestor = ingestor
+ self._single_file: Path | None = None
+ if repo_path.is_file():
+ resolved = repo_path.resolve()
+ self._single_file = resolved
+ repo_path = resolved.parent
self.repo_path = repo_path
self.parsers = parsers
self.queries = queries
- self.project_name = repo_path.resolve().name
+ self.project_name = (
+ project_name and project_name.strip()
+ ) or repo_path.resolve().name
self.simple_name_lookup: SimpleNameLookup = defaultdict(set)
self.function_registry = FunctionRegistryTrie(
simple_name_lookup=self.simple_name_lookup
@@ -242,6 +439,9 @@ def __init__(
self.ast_cache = BoundedASTCache()
self.unignore_paths = unignore_paths
self.exclude_paths = exclude_paths
+ self.skipped_because_in_sync = False
+ self._collected_dir_mtimes: DirMtimesCache = {}
+ self._cpp_frontend_covered: frozenset[str] = frozenset()
self.factory = ProcessorFactory(
ingestor=self.ingestor,
@@ -255,25 +455,77 @@ def __init__(
exclude_paths=self.exclude_paths,
)
+ def _run_cpp_frontend(self) -> None:
+ # (H) Optional libclang C++ pre-pass: when CPP_FRONTEND=libclang and a
+ # (H) compile_commands.json is discoverable, emit macro-accurate C/C++
+ # (H) nodes/edges directly (tree-sitter cannot expand macros). Covered
+ # (H) files are then skipped by the tree-sitter definition pass. Missing
+ # (H) either condition falls back to tree-sitter with no change.
+ self._cpp_frontend_covered = frozenset()
+ if settings.CPP_FRONTEND != cs.CppFrontend.LIBCLANG:
+ return
+ if not cpp_frontend_available():
+ logger.warning(ls.CPP_FRONTEND_UNAVAILABLE)
+ return
+ compdb_dir = find_compile_commands(self.repo_path)
+ if compdb_dir is None:
+ logger.warning(ls.CPP_FRONTEND_NO_COMPDB)
+ return
+ logger.info(ls.CPP_FRONTEND_RUNNING.format(path=compdb_dir))
+ self._cpp_frontend_covered = run_cpp_frontend(
+ self.ingestor,
+ self.repo_path,
+ self.project_name,
+ compdb_dir,
+ function_registry=self.function_registry,
+ simple_name_lookup=self.simple_name_lookup,
+ structural_elements=self.factory.structure_processor.structural_elements,
+ )
+ logger.info(
+ ls.CPP_FRONTEND_COVERED.format(count=len(self._cpp_frontend_covered))
+ )
+
def _is_dependency_file(self, file_name: str, filepath: Path) -> bool:
return (
file_name.lower() in cs.DEPENDENCY_FILES
or filepath.suffix.lower() == cs.CSPROJ_SUFFIX
)
- def run(self) -> None:
+ def run(self, force: bool = False) -> None:
+ py_engine = self.factory.type_inference._python_type_inference
+ if py_engine is not None:
+ py_engine._available_classes_cache.clear()
+ py_engine._return_stmt_cache.clear()
+ py_engine._method_return_type_cache.clear()
+ py_engine._self_assignment_cache.clear()
self.ingestor.ensure_node_batch(
cs.NODE_PROJECT, {cs.KEY_NAME: self.project_name}
)
- logger.info(ls.ENSURING_PROJECT.format(name=self.project_name))
+ logger.info(ls.ENSURING_PROJECT, name=self.project_name)
+
+ if not force and self._is_already_in_sync():
+ logger.info(ls.GRAPH_ALREADY_IN_SYNC)
+ self.skipped_because_in_sync = True
+ self.ingestor.flush_all()
+ return
logger.info(ls.PASS_1_STRUCTURE)
self.factory.structure_processor.identify_structure()
+ self._run_cpp_frontend()
+
logger.info(ls.PASS_2_FILES)
- self._process_files()
+ self._process_files(force=force)
- logger.info(ls.FOUND_FUNCTIONS.format(count=len(self.function_registry)))
+ corrected = self.factory.definition_processor.resolve_deferred_cpp_methods()
+ if corrected:
+ logger.info("Resolved {} deferred C++ out-of-class methods", corrected)
+
+ go_methods = self.factory.definition_processor.resolve_deferred_go_methods()
+ if go_methods:
+ logger.info("Resolved {} Go receiver methods", go_methods)
+
+ logger.info(ls.FOUND_FUNCTIONS, count=len(self.function_registry))
logger.info(ls.PASS_3_CALLS)
self._process_function_calls()
@@ -282,16 +534,18 @@ def run(self) -> None:
logger.info(ls.ANALYSIS_COMPLETE)
self.ingestor.flush_all()
+ self._prune_orphan_nodes()
+
self._generate_semantic_embeddings()
def remove_file_from_state(self, file_path: Path) -> None:
- logger.debug(ls.REMOVING_STATE.format(path=file_path))
+ logger.debug(ls.REMOVING_STATE, path=file_path)
if file_path in self.ast_cache:
del self.ast_cache[file_path]
logger.debug(ls.REMOVED_FROM_CACHE)
- relative_path = file_path.relative_to(self.repo_path)
+ relative_path = cached_relative_path(file_path, self.repo_path)
path_parts = (
relative_path.parent.parts
if file_path.name == cs.INIT_PY
@@ -307,51 +561,480 @@ def remove_file_from_state(self, file_path: Path) -> None:
del self.function_registry[qn]
if qns_to_remove:
- logger.debug(ls.REMOVING_QNS.format(count=len(qns_to_remove)))
+ logger.debug(ls.REMOVING_QNS, count=len(qns_to_remove))
for simple_name, qn_set in self.simple_name_lookup.items():
original_count = len(qn_set)
new_qn_set = qn_set - qns_to_remove
if len(new_qn_set) < original_count:
self.simple_name_lookup[simple_name] = new_qn_set
- logger.debug(ls.CLEANED_SIMPLE_NAME.format(name=simple_name))
+ logger.debug(ls.CLEANED_SIMPLE_NAME, name=simple_name)
+
+ def _delete_module_entities(self, file_key: str) -> None:
+ """Remove a changed/deleted file's Module subtree from the graph.
+
+ The incremental path re-parses a changed file and re-adds its
+ entities, but the entities the previous parse contributed (the
+ Module and everything it DEFINES, plus their IMPORTS/CALLS edges via
+ DETACH) must be removed first; otherwise renamed-away Function/Class/
+ Method nodes and their edges linger alongside the new ones.
+ """
+ if isinstance(self.ingestor, QueryProtocol):
+ self.ingestor.execute_write(
+ cs.CYPHER_DELETE_MODULE, {cs.KEY_PATH: file_key}
+ )
- def _process_files(self) -> None:
- for filepath in self.repo_path.rglob("*"):
- if filepath.is_file() and not should_skip_path(
- filepath,
+ def _diff_dir_against_cache(
+ self,
+ dir_path_str: str,
+ dir_key: str,
+ old_hashes: FileHashCache,
+ old_dir_mtimes: DirMtimesCache,
+ ) -> tuple[str | None, str | None]:
+ prefix = "" if dir_key == cs.ROOT_DIR_KEY else f"{dir_key}/"
+ expected_files: set[str] = set()
+ expected_dirs: set[str] = set()
+ for fk in old_hashes:
+ if fk.startswith(prefix):
+ rest = fk[len(prefix) :]
+ if "/" not in rest:
+ expected_files.add(rest)
+ for dk in old_dir_mtimes:
+ if dk == cs.ROOT_DIR_KEY or not dk.startswith(prefix):
+ continue
+ rest = dk[len(prefix) :]
+ if "/" not in rest:
+ expected_dirs.add(rest)
+
+ actual_files: set[str] = set()
+ actual_dirs: set[str] = set()
+ try:
+ with os.scandir(dir_path_str) as it:
+ for entry in it:
+ name = entry.name
+ if name in (cs.HASH_CACHE_FILENAME, cs.DIR_MTIMES_FILENAME):
+ continue
+ try:
+ is_symlink = entry.is_symlink()
+ except OSError:
+ is_symlink = False
+ try:
+ is_dir_following = entry.is_dir()
+ except OSError:
+ is_dir_following = False
+ if is_symlink and is_dir_following:
+ continue
+ if is_dir_following:
+ actual_dirs.add(name)
+ else:
+ actual_files.add(name)
+ except OSError:
+ return None, dir_key
+
+ dir_parts: tuple[str, ...] = (
+ () if dir_key == cs.ROOT_DIR_KEY else tuple(dir_key.split("/"))
+ )
+ dir_prefix_for_keep = "" if dir_key == cs.ROOT_DIR_KEY else f"{dir_key}/"
+
+ for name in actual_dirs - expected_dirs:
+ if not self._should_keep_dir(name, dir_prefix_for_keep):
+ continue
+ return f"{prefix}{name}", None
+ for name in actual_files - expected_files:
+ dot = name.rfind(".")
+ suffix = name[dot:] if dot != -1 else ""
+ if should_skip_rel_file(
+ f"{prefix}{name}",
+ dir_parts,
+ suffix,
+ exclude_paths=self.exclude_paths,
+ unignore_paths=self.unignore_paths,
+ ):
+ continue
+ return f"{prefix}{name}", None
+
+ for name in expected_files - actual_files:
+ return None, f"{prefix}{name}"
+ for name in expected_dirs - actual_dirs:
+ return None, f"{prefix}{name}"
+
+ return None, None
+
+ def _should_keep_dir(self, dirname: str, dir_prefix: str) -> bool:
+ if dirname not in cs.IGNORE_PATTERNS and (
+ not self.exclude_paths or dirname not in self.exclude_paths
+ ):
+ return True
+ return bool(
+ self.unignore_paths
+ and any(
+ u.startswith(f"{dir_prefix}{dirname}/") or u == f"{dir_prefix}{dirname}"
+ for u in self.unignore_paths
+ )
+ )
+
+ def _is_already_in_sync(self) -> bool:
+ if self._single_file is not None:
+ return False
+ cache_path = self.repo_path / cs.HASH_CACHE_FILENAME
+ if not cache_path.is_file():
+ return False
+ cache_mtime = cache_path.stat().st_mtime
+ dir_mtimes_path = self.repo_path / cs.DIR_MTIMES_FILENAME
+ old_hashes = _load_hash_cache(cache_path)
+ old_dir_mtimes = _load_dir_mtimes(dir_mtimes_path)
+ if not old_hashes or not old_dir_mtimes:
+ return False
+
+ repo_str = str(self.repo_path)
+ for dir_key, cached_mtime in old_dir_mtimes.items():
+ dir_path_str = (
+ repo_str if dir_key == cs.ROOT_DIR_KEY else f"{repo_str}/{dir_key}"
+ )
+ try:
+ current_mtime = os.stat(dir_path_str).st_mtime
+ except OSError:
+ return False
+ if current_mtime != cached_mtime:
+ addition, removal = self._diff_dir_against_cache(
+ dir_path_str, dir_key, old_hashes, old_dir_mtimes
+ )
+ if addition is not None or removal is not None:
+ return False
+
+ for file_key, old_hash in old_hashes.items():
+ file_path_str = f"{repo_str}/{file_key}"
+ try:
+ stat = os.stat(file_path_str)
+ except OSError:
+ return False
+ if stat.st_mtime <= cache_mtime:
+ continue
+ if _hash_file(Path(file_path_str)) != old_hash:
+ return False
+ return True
+
+ def _collect_eligible_files(self) -> list[tuple[Path, str]]:
+ if self._single_file is not None:
+ if not should_skip_path(
+ self._single_file,
self.repo_path,
exclude_paths=self.exclude_paths,
unignore_paths=self.unignore_paths,
):
- lang_config = get_language_spec(filepath.suffix)
- if (
- lang_config
- and isinstance(lang_config.language, cs.SupportedLanguage)
- and lang_config.language in self.parsers
+ file_key = cached_relative_path(
+ self._single_file, self.repo_path
+ ).as_posix()
+ return [(self._single_file, file_key)]
+ return []
+
+ eligible: list[tuple[Path, str]] = []
+ hash_name = cs.HASH_CACHE_FILENAME
+ dir_mtimes_name = cs.DIR_MTIMES_FILENAME
+ repo_str = str(self.repo_path)
+ repo_prefix_len = len(repo_str) + 1
+ exclude_paths = self.exclude_paths
+ unignore_paths = self.unignore_paths
+ self._collected_dir_mtimes = {}
+ for dirpath, dirnames, filenames in os.walk(repo_str):
+ if len(dirpath) < repo_prefix_len:
+ rel_dir = ""
+ dir_parts: tuple[str, ...] = ()
+ dir_key = cs.ROOT_DIR_KEY
+ else:
+ rel_dir = dirpath[repo_prefix_len:].replace(os.sep, "/")
+ dir_parts = tuple(rel_dir.split("/")) if rel_dir else ()
+ dir_key = rel_dir or cs.ROOT_DIR_KEY
+ dir_prefix = f"{rel_dir}/" if rel_dir else ""
+ try:
+ self._collected_dir_mtimes[dir_key] = os.stat(dirpath).st_mtime
+ except OSError:
+ pass
+ dirnames[:] = sorted(
+ d for d in dirnames if self._should_keep_dir(d, dir_prefix)
+ )
+ for fname in sorted(filenames):
+ if fname in (hash_name, dir_mtimes_name):
+ continue
+ dot = fname.rfind(".")
+ suffix = fname[dot:] if dot != -1 else ""
+ rel_path_str = f"{dir_prefix}{fname}"
+ if not should_skip_rel_file(
+ rel_path_str,
+ dir_parts,
+ suffix,
+ exclude_paths=exclude_paths,
+ unignore_paths=unignore_paths,
):
- result = self.factory.definition_processor.process_file(
- filepath,
- lang_config.language,
- self.queries,
- self.factory.structure_processor.structural_elements,
+ eligible.append((Path(f"{dirpath}/{fname}"), rel_path_str))
+ return eligible
+
+ def _process_files(self, force: bool = False) -> None:
+ cache_path = self.repo_path / cs.HASH_CACHE_FILENAME
+ dir_mtimes_path = self.repo_path / cs.DIR_MTIMES_FILENAME
+ old_hashes = _load_hash_cache(cache_path) if not force else {}
+ cache_mtime = cache_path.stat().st_mtime if cache_path.is_file() else 0.0
+ if force:
+ logger.info(ls.INCREMENTAL_FORCE)
+
+ _touch_empty_json(cache_path)
+ _touch_empty_json(dir_mtimes_path)
+
+ eligible_files = self._collect_eligible_files()
+ new_hashes: FileHashCache = {}
+ skipped_count = 0
+ changed_count = 0
+ unreadable_count = 0
+
+ current_file_keys: set[str] = set()
+
+ processed_since_flush = 0
+
+ changed_entries: list[tuple[Path, str, bool, bytes]] = []
+ for filepath, file_key in eligible_files:
+ if not force and file_key in old_hashes:
+ try:
+ file_mtime = filepath.stat().st_mtime
+ except OSError:
+ unreadable_count += 1
+ continue
+ if file_mtime <= cache_mtime:
+ new_hashes[file_key] = old_hashes[file_key]
+ current_file_keys.add(file_key)
+ skipped_count += 1
+ continue
+
+ hashed = _hash_file_with_bytes(filepath)
+ if hashed is None:
+ unreadable_count += 1
+ continue
+ current_hash, file_bytes = hashed
+
+ current_file_keys.add(file_key)
+ new_hashes[file_key] = current_hash
+
+ if (
+ not force
+ and file_key in old_hashes
+ and old_hashes[file_key] == current_hash
+ ):
+ logger.debug(ls.FILE_HASH_UNCHANGED, path=file_key)
+ skipped_count += 1
+ continue
+
+ is_new = file_key not in old_hashes
+ if not is_new:
+ logger.debug(ls.FILE_HASH_CHANGED, path=file_key)
+ else:
+ logger.debug(ls.FILE_HASH_NEW, path=file_key)
+ changed_entries.append((filepath, file_key, is_new, file_bytes))
+
+ pre_parsed = self._pre_parse_changed_files(changed_entries)
+
+ with Progress(
+ SpinnerColumn(),
+ TextColumn(ls.PROGRESS_INDEXING_LABEL),
+ TextColumn("[progress.description]{task.description}"),
+ transient=True,
+ disable=not sys.stderr.isatty(),
+ ) as progress:
+ task = progress.add_task("", total=len(eligible_files))
+ if skipped_count or unreadable_count:
+ progress.advance(task, skipped_count + unreadable_count)
+
+ for filepath, file_key, is_new, file_bytes in changed_entries:
+ if not is_new:
+ self.remove_file_from_state(filepath)
+ self._delete_module_entities(file_key)
+
+ changed_count += 1
+ self._process_single_file(
+ filepath,
+ file_bytes=file_bytes,
+ pre_parsed=pre_parsed.get(filepath),
+ )
+
+ processed_since_flush += 1
+ if processed_since_flush >= settings.FILE_FLUSH_INTERVAL:
+ logger.info(ls.PERIODIC_FLUSH.format(count=processed_since_flush))
+ self.ingestor.flush_all()
+ processed_since_flush = 0
+
+ progress.update(
+ task,
+ advance=1,
+ description=ls.PROGRESS_FILES_PROCESSED.format(count=changed_count),
+ )
+
+ deleted_keys = set(old_hashes.keys()) - current_file_keys
+ if deleted_keys:
+ logger.info(ls.INCREMENTAL_DELETED, count=len(deleted_keys))
+ for deleted_key in deleted_keys:
+ deleted_path = self.repo_path / deleted_key
+ self.remove_file_from_state(deleted_path)
+ self._delete_module_entities(deleted_key)
+ if isinstance(self.ingestor, QueryProtocol):
+ self.ingestor.execute_write(
+ cs.CYPHER_DELETE_FILE, {cs.KEY_PATH: deleted_key}
)
- if result:
- root_node, language = result
- self.ast_cache[filepath] = (root_node, language)
- elif self._is_dependency_file(filepath.name, filepath):
- self.factory.definition_processor.process_dependencies(filepath)
+ if skipped_count > 0:
+ logger.info(ls.INCREMENTAL_SKIPPED, count=skipped_count)
+ if changed_count > 0:
+ logger.info(ls.INCREMENTAL_CHANGED, count=changed_count)
+ if unreadable_count > 0:
+ logger.info(ls.INCREMENTAL_UNREADABLE, count=unreadable_count)
+
+ _save_hash_cache(cache_path, new_hashes)
+ _save_dir_mtimes(dir_mtimes_path, self._collected_dir_mtimes)
+
+ def _pre_parse_changed_files(
+ self,
+ changed_entries: list[tuple[Path, str, bool, bytes]],
+ ) -> dict[Path, tuple[Node, dict[str, list] | None]]:
+ result: dict[Path, tuple[Node, dict[str, list] | None]] = {}
+ for filepath, _file_key, _is_new, file_bytes in changed_entries:
+ lang_config = get_language_spec(filepath.suffix)
+ if not (
+ lang_config
+ and isinstance(lang_config.language, cs.SupportedLanguage)
+ and lang_config.language in self.parsers
+ ):
+ continue
+ language = lang_config.language
+ parser = self.queries[language].get(cs.KEY_PARSER)
+ if not parser:
+ continue
+ tree = parser.parse(file_bytes)
+ root_node = tree.root_node
+ combined_query = COMBINED_FUNC_CLASS_IMPORT_QUERIES.get(language)
+ combined_captures: dict[str, list] | None = None
+ if combined_query:
+ cursor = QueryCursor(combined_query)
+ combined_captures = sorted_captures(cursor, root_node)
+ result[filepath] = (root_node, combined_captures)
+ return result
+
+ def _process_single_file(
+ self,
+ filepath: Path,
+ file_bytes: bytes | None = None,
+ pre_parsed: tuple[Node, dict[str, list] | None] | None = None,
+ ) -> None:
+ if self._cpp_frontend_covered:
+ rel = cached_relative_path(filepath, self.repo_path).as_posix()
+ if rel in self._cpp_frontend_covered:
+ # (H) The libclang frontend already emitted this file's
+ # (H) definitions; keep only the generic File node.
self.factory.structure_processor.process_generic_file(
filepath, filepath.name
)
+ return
+
+ lang_config = get_language_spec(filepath.suffix)
+ if (
+ lang_config
+ and isinstance(lang_config.language, cs.SupportedLanguage)
+ and lang_config.language in self.parsers
+ ):
+ result = self.factory.definition_processor.process_file(
+ filepath,
+ lang_config.language,
+ self.queries,
+ self.factory.structure_processor.structural_elements,
+ source_bytes=file_bytes,
+ pre_parsed=pre_parsed,
+ )
+ if result:
+ root_node, language = result
+ self.ast_cache[filepath] = (root_node, language)
+ elif self._is_dependency_file(filepath.name, filepath):
+ self.factory.definition_processor.process_dependencies(filepath)
+
+ self.factory.structure_processor.process_generic_file(filepath, filepath.name)
def _process_function_calls(self) -> None:
+ captures_cache = self.factory._func_class_captures_cache
ast_cache_items = list(self.ast_cache.items())
for file_path, (root_node, language) in ast_cache_items:
+ self.factory.call_processor.collect_callable_field_bindings(
+ file_path,
+ root_node,
+ language,
+ self.queries,
+ func_class_captures_cache=captures_cache,
+ )
+ for file_path, (root_node, language) in ast_cache_items:
+ if captures_cache is not None and file_path in captures_cache:
+ cached = captures_cache[file_path]
+ if not cached.get(cs.CAPTURE_CALL) and not cached.get(
+ cs.CAPTURE_FUNCTION
+ ):
+ continue
self.factory.call_processor.process_calls_in_file(
- file_path, root_node, language, self.queries
+ file_path,
+ root_node,
+ language,
+ self.queries,
+ func_class_captures_cache=captures_cache,
)
+ self.factory.call_processor.finalize_callable_param_flow()
+
+ def _prune_orphan_nodes(self) -> None:
+ """Remove graph nodes whose files/folders no longer exist on disk."""
+ if not isinstance(self.ingestor, QueryProtocol):
+ return
+
+ logger.info(ls.PRUNE_START)
+ total_pruned = 0
+
+ project_prefix = self.project_name + "."
+ repo_abs = self.repo_path.resolve().as_posix()
+ prune_specs: list[tuple[str, str, str]] = [
+ (cs.CYPHER_ALL_FILE_PATHS, cs.CYPHER_DELETE_FILE, "File"),
+ (
+ cs.CYPHER_ALL_MODULE_PATHS_INTERNAL,
+ cs.CYPHER_DELETE_MODULE,
+ "Module",
+ ),
+ (cs.CYPHER_ALL_FOLDER_PATHS, cs.CYPHER_DELETE_FOLDER, "Folder"),
+ ]
+
+ for query_all, delete_query, label in prune_specs:
+ rows = self.ingestor.fetch_all(query_all)
+ orphans = []
+ for r in rows:
+ path = r.get("path")
+ if not isinstance(path, str) or not path:
+ continue
+ if path.startswith(cs.INLINE_MODULE_PATH_PREFIX):
+ continue
+ abs_path = r.get("absolute_path")
+ qn = r.get("qualified_name", "")
+ if isinstance(abs_path, str) and not abs_path.startswith(repo_abs):
+ continue
+ if isinstance(qn, str) and qn and not qn.startswith(project_prefix):
+ continue
+ if not (self.repo_path / path).exists():
+ orphans.append(path)
+
+ if orphans:
+ logger.info(ls.PRUNE_FOUND, count=len(orphans), label=label)
+ for orphan_path in orphans:
+ logger.debug(ls.PRUNE_DELETING, label=label, path=orphan_path)
+ self.ingestor.execute_write(
+ delete_query, {cs.KEY_PATH: orphan_path}
+ )
+ total_pruned += len(orphans)
+
+ # (H) Drop external import-target modules that no module imports anymore,
+ # (H) e.g. an imported name renamed/removed on an incremental rebuild.
+ self.ingestor.execute_write(cs.CYPHER_DELETE_ORPHAN_EXTERNAL_MODULES)
+
+ if total_pruned:
+ logger.info(ls.PRUNE_COMPLETE, count=total_pruned)
+ else:
+ logger.info(ls.PRUNE_SKIP)
def _generate_semantic_embeddings(self) -> None:
if not has_semantic_dependencies():
@@ -363,22 +1046,55 @@ def _generate_semantic_embeddings(self) -> None:
return
try:
- from .embedder import embed_code
- from .vector_store import store_embedding
+ from .embedder import embed_code_batch, get_embedding_cache
+ from .vector_store import (
+ close_qdrant_client,
+ store_embedding_batch,
+ verify_stored_ids,
+ )
logger.info(ls.PASS_4_EMBEDDINGS)
results = self.ingestor.fetch_all(
- cs.CYPHER_QUERY_EMBEDDINGS, {"project_name": self.project_name + "."}
+ cs.CYPHER_QUERY_EMBEDDINGS, {"project_name": self.project_name}
)
if not results:
logger.info(ls.NO_FUNCTIONS_FOR_EMBEDDING)
return
- logger.info(ls.GENERATING_EMBEDDINGS.format(count=len(results)))
+ logger.info(ls.GENERATING_EMBEDDINGS, count=len(results))
embedded_count = 0
+ expected_ids: set[int] = set()
+ pending: list[tuple[int, str, str]] = []
+ flush_at = settings.QDRANT_BATCH_SIZE
+
+ def flush() -> int:
+ nonlocal pending
+ if not pending:
+ return 0
+ snippets = [item[2] for item in pending]
+ try:
+ embeddings = embed_code_batch(snippets)
+ except Exception as e:
+ logger.warning(
+ ls.EMBEDDING_BATCH_COMPUTE_FAILED,
+ count=len(pending),
+ error=e,
+ )
+ pending = []
+ return 0
+ points: list[tuple[int, list[float], str]] = [
+ (node_id, emb, qname)
+ for (node_id, qname, _), emb in zip(pending, embeddings)
+ ]
+ for node_id, _qname, _src in pending:
+ expected_ids.add(node_id)
+ stored = store_embedding_batch(points)
+ pending = []
+ return stored
+
for row in results:
parsed = self._parse_embedding_result(row)
if parsed is None:
@@ -391,33 +1107,62 @@ def _generate_semantic_embeddings(self) -> None:
file_path = parsed.get(cs.KEY_PATH)
if start_line is None or end_line is None or file_path is None:
- logger.debug(ls.NO_SOURCE_FOR.format(name=qualified_name))
+ logger.debug(ls.NO_SOURCE_FOR, name=qualified_name)
+ continue
- elif source_code := self._extract_source_code(
+ if source_code := self._extract_source_code(
qualified_name, file_path, start_line, end_line
):
- try:
- embedding = embed_code(source_code)
- store_embedding(node_id, embedding, qualified_name)
- embedded_count += 1
-
- if embedded_count % settings.EMBEDDING_PROGRESS_INTERVAL == 0:
+ pending.append((node_id, qualified_name, source_code))
+ if len(pending) >= flush_at:
+ embedded_count += flush()
+ if (
+ embedded_count % settings.EMBEDDING_PROGRESS_INTERVAL == 0
+ and embedded_count > 0
+ ):
logger.debug(
- ls.EMBEDDING_PROGRESS.format(
- done=embedded_count, total=len(results)
- )
+ ls.EMBEDDING_PROGRESS,
+ done=embedded_count,
+ total=len(results),
)
-
- except Exception as e:
- logger.warning(
- ls.EMBEDDING_FAILED.format(name=qualified_name, error=e)
- )
else:
- logger.debug(ls.NO_SOURCE_FOR.format(name=qualified_name))
- logger.info(ls.EMBEDDINGS_COMPLETE.format(count=embedded_count))
+ logger.debug(ls.NO_SOURCE_FOR, name=qualified_name)
+
+ embedded_count += flush()
+
+ logger.info(ls.EMBEDDINGS_COMPLETE, count=embedded_count)
+
+ self._reconcile_embeddings(expected_ids, verify_stored_ids)
+
+ get_embedding_cache().save()
+ close_qdrant_client()
+
+ except Exception as e:
+ logger.warning(ls.EMBEDDING_GENERATION_FAILED, error=e)
+ def _reconcile_embeddings(
+ self,
+ expected_ids: set[int],
+ verify_fn: Callable[[set[int]], set[int]],
+ ) -> None:
+ if not expected_ids:
+ return
+ try:
+ stored_ids = verify_fn(expected_ids)
+ missing = expected_ids - stored_ids
+ if missing:
+ sample = sorted(missing)[:10]
+ logger.warning(
+ ls.EMBEDDING_RECONCILE_MISSING.format(
+ missing=len(missing),
+ expected=len(expected_ids),
+ sample_ids=sample,
+ )
+ )
+ else:
+ logger.info(ls.EMBEDDING_RECONCILE_OK.format(count=len(expected_ids)))
except Exception as e:
- logger.warning(ls.EMBEDDING_GENERATION_FAILED.format(error=e))
+ logger.warning(ls.EMBEDDING_RECONCILE_FAILED.format(error=e))
def _extract_source_code(
self, qualified_name: str, file_path: str, start_line: int, end_line: int
diff --git a/codebase_rag/language_spec.py b/codebase_rag/language_spec.py
index cf550ab08..a48b6442b 100644
--- a/codebase_rag/language_spec.py
+++ b/codebase_rag/language_spec.py
@@ -82,6 +82,14 @@ def _rust_get_name(node: Node) -> str | None:
name_node = node.child_by_field_name(cs.FIELD_NAME)
if name_node and name_node.type == cs.TS_IDENTIFIER and name_node.text:
return name_node.text.decode(cs.ENCODING_UTF8)
+ elif node.type == cs.TS_IMPL_ITEM:
+ # (H) An `impl Foo` block is an FQN scope, but it has no `name` field; its
+ # (H) target type is the segment that anchors its methods' qns
+ # (H) (owner_module.Foo.method). Without this the scope walk drops `Foo`, so
+ # (H) a closure/nested fn in an impl method binds to a phantom parent qn.
+ from .parsers.rs import utils as rs_utils
+
+ return rs_utils.extract_impl_target(node)
return _generic_get_name(node)
@@ -97,6 +105,38 @@ def _rust_file_to_module(file_path: Path, repo_root: Path) -> list[str]:
return []
+def _php_file_to_module(file_path: Path, repo_root: Path) -> list[str]:
+ try:
+ rel = file_path.relative_to(repo_root)
+ parts = list(rel.with_suffix("").parts)
+ if parts and parts[0] in ("src", "app", "lib"):
+ parts = parts[1:]
+ return parts
+ except ValueError:
+ return []
+
+
+def _c_unwrap_declarator(declarator: Node | None) -> Node | None:
+ while declarator and declarator.type == cs.CppNodeType.POINTER_DECLARATOR:
+ declarator = declarator.child_by_field_name(cs.FIELD_DECLARATOR)
+ return declarator
+
+
+def _c_get_name(node: Node) -> str | None:
+ if node.type in cs.C_NAME_NODE_TYPES:
+ name_node = node.child_by_field_name(cs.FIELD_NAME)
+ if name_node and name_node.text:
+ return name_node.text.decode(cs.ENCODING_UTF8)
+ elif node.type == cs.TS_CPP_FUNCTION_DEFINITION:
+ declarator = node.child_by_field_name(cs.FIELD_DECLARATOR)
+ declarator = _c_unwrap_declarator(declarator)
+ if declarator and declarator.type == cs.TS_CPP_FUNCTION_DECLARATOR:
+ name_node = declarator.child_by_field_name(cs.FIELD_DECLARATOR)
+ if name_node and name_node.type == cs.TS_IDENTIFIER and name_node.text:
+ return name_node.text.decode(cs.ENCODING_UTF8)
+ return _generic_get_name(node)
+
+
def _cpp_get_name(node: Node) -> str | None:
if node.type in cs.CPP_NAME_NODE_TYPES:
name_node = node.child_by_field_name(cs.FIELD_NAME)
@@ -154,6 +194,13 @@ def _cpp_get_name(node: Node) -> str | None:
file_to_module_parts=_generic_file_to_module,
)
+C_FQN_SPEC = FQNSpec(
+ scope_node_types=frozenset(cs.FQN_C_SCOPE_TYPES),
+ function_node_types=frozenset(cs.FQN_C_FUNCTION_TYPES),
+ get_name=_c_get_name,
+ file_to_module_parts=_generic_file_to_module,
+)
+
LUA_FQN_SPEC = FQNSpec(
scope_node_types=frozenset(cs.FQN_LUA_SCOPE_TYPES),
function_node_types=frozenset(cs.FQN_LUA_FUNCTION_TYPES),
@@ -175,18 +222,11 @@ def _cpp_get_name(node: Node) -> str | None:
file_to_module_parts=_generic_file_to_module,
)
-CSHARP_FQN_SPEC = FQNSpec(
- scope_node_types=frozenset(cs.FQN_CS_SCOPE_TYPES),
- function_node_types=frozenset(cs.FQN_CS_FUNCTION_TYPES),
- get_name=_generic_get_name,
- file_to_module_parts=_generic_file_to_module,
-)
-
PHP_FQN_SPEC = FQNSpec(
scope_node_types=frozenset(cs.FQN_PHP_SCOPE_TYPES),
function_node_types=frozenset(cs.FQN_PHP_FUNCTION_TYPES),
get_name=_generic_get_name,
- file_to_module_parts=_generic_file_to_module,
+ file_to_module_parts=_php_file_to_module,
)
LANGUAGE_FQN_SPECS: dict[cs.SupportedLanguage, FQNSpec] = {
@@ -195,11 +235,11 @@ def _cpp_get_name(node: Node) -> str | None:
cs.SupportedLanguage.TS: TS_FQN_SPEC,
cs.SupportedLanguage.RUST: RUST_FQN_SPEC,
cs.SupportedLanguage.JAVA: JAVA_FQN_SPEC,
+ cs.SupportedLanguage.C: C_FQN_SPEC,
cs.SupportedLanguage.CPP: CPP_FQN_SPEC,
cs.SupportedLanguage.LUA: LUA_FQN_SPEC,
cs.SupportedLanguage.GO: GO_FQN_SPEC,
cs.SupportedLanguage.SCALA: SCALA_FQN_SPEC,
- cs.SupportedLanguage.CSHARP: CSHARP_FQN_SPEC,
cs.SupportedLanguage.PHP: PHP_FQN_SPEC,
}
@@ -285,8 +325,14 @@ def _cpp_get_name(node: Node) -> str | None:
function: (scoped_identifier
"::"
name: (identifier) @name)) @call
+ (call_expression
+ function: (generic_function) @name) @call
(macro_invocation
macro: (identifier) @name) @call
+ (token_tree
+ (identifier) @name @call
+ .
+ (token_tree . "("))
""",
),
cs.SupportedLanguage.GO: LanguageSpec(
@@ -343,6 +389,28 @@ def _cpp_get_name(node: Node) -> str | None:
type: (type_identifier) @name) @call
""",
),
+ cs.SupportedLanguage.C: LanguageSpec(
+ language=cs.SupportedLanguage.C,
+ file_extensions=cs.C_EXTENSIONS,
+ function_node_types=cs.SPEC_C_FUNCTION_TYPES,
+ class_node_types=cs.SPEC_C_CLASS_TYPES,
+ module_node_types=cs.SPEC_C_MODULE_TYPES,
+ call_node_types=cs.SPEC_C_CALL_TYPES,
+ import_node_types=cs.IMPORT_NODES_INCLUDE,
+ import_from_node_types=cs.IMPORT_NODES_INCLUDE,
+ package_indicators=cs.SPEC_C_PACKAGE_INDICATORS,
+ function_query="""
+ (function_definition) @function
+ """,
+ class_query="""
+ (struct_specifier) @class
+ (union_specifier) @class
+ (enum_specifier) @class
+ """,
+ call_query="""
+ (call_expression) @call
+ """,
+ ),
cs.SupportedLanguage.CPP: LanguageSpec(
language=cs.SupportedLanguage.CPP,
file_extensions=cs.CPP_EXTENSIONS,
@@ -381,16 +449,6 @@ def _cpp_get_name(node: Node) -> str | None:
(delete_expression) @call
""",
),
- cs.SupportedLanguage.CSHARP: LanguageSpec(
- language=cs.SupportedLanguage.CSHARP,
- file_extensions=cs.CS_EXTENSIONS,
- function_node_types=cs.SPEC_CS_FUNCTION_TYPES,
- class_node_types=cs.SPEC_CS_CLASS_TYPES,
- module_node_types=cs.SPEC_CS_MODULE_TYPES,
- call_node_types=cs.SPEC_CS_CALL_TYPES,
- import_node_types=cs.IMPORT_NODES_USING,
- import_from_node_types=cs.IMPORT_NODES_USING,
- ),
cs.SupportedLanguage.PHP: LanguageSpec(
language=cs.SupportedLanguage.PHP,
file_extensions=cs.PHP_EXTENSIONS,
@@ -398,6 +456,42 @@ def _cpp_get_name(node: Node) -> str | None:
class_node_types=cs.SPEC_PHP_CLASS_TYPES,
module_node_types=cs.SPEC_PHP_MODULE_TYPES,
call_node_types=cs.SPEC_PHP_CALL_TYPES,
+ import_node_types=cs.SPEC_PHP_IMPORT_TYPES,
+ import_from_node_types=cs.SPEC_PHP_IMPORT_FROM_TYPES,
+ function_query="""
+ (function_definition
+ name: (name) @name) @function
+ (method_declaration
+ name: (name) @name) @function
+ (anonymous_function) @function
+ (arrow_function) @function
+ """,
+ class_query="""
+ (class_declaration
+ name: (name) @name) @class
+ (interface_declaration
+ name: (name) @name) @class
+ (trait_declaration
+ name: (name) @name) @class
+ (enum_declaration
+ name: (name) @name) @class
+ """,
+ call_query="""
+ (function_call_expression
+ function: (name) @name) @call
+ (function_call_expression
+ function: (qualified_name) @name) @call
+ (member_call_expression
+ name: (name) @name) @call
+ (scoped_call_expression
+ name: (name) @name) @call
+ (nullsafe_member_call_expression
+ name: (name) @name) @call
+ (object_creation_expression
+ (name) @name) @call
+ (object_creation_expression
+ (qualified_name) @name) @call
+ """,
),
cs.SupportedLanguage.LUA: LanguageSpec(
language=cs.SupportedLanguage.LUA,
diff --git a/codebase_rag/logs.py b/codebase_rag/logs.py
index 3e075c877..9fb10305b 100644
--- a/codebase_rag/logs.py
+++ b/codebase_rag/logs.py
@@ -13,6 +13,17 @@
)
PASS_3_CALLS = "--- Pass 3: Processing Function Calls from AST Cache ---"
PASS_4_EMBEDDINGS = "--- Pass 4: Generating semantic embeddings ---"
+CPP_FRONTEND_RUNNING = "--- C/C++ libclang frontend: {path} ---"
+CPP_FRONTEND_UNAVAILABLE = (
+ "CPP_FRONTEND=libclang but libclang is unavailable; using tree-sitter"
+)
+CPP_FRONTEND_NO_COMPDB = (
+ "CPP_FRONTEND=libclang but no compile_commands.json found; using tree-sitter"
+)
+CPP_FRONTEND_COVERED = "C/C++ libclang frontend covered {count} file(s)"
+GRAPH_ALREADY_IN_SYNC = (
+ "Knowledge graph already in sync (hash cache matches every file). Skipping passes."
+)
# (H) Analysis logs
FOUND_FUNCTIONS = "\n--- Found {count} functions/methods in codebase ---"
@@ -45,14 +56,40 @@
GENERATING_EMBEDDINGS = "Generating embeddings for {count} functions/methods"
EMBEDDING_PROGRESS = "Generated {done}/{total} embeddings"
EMBEDDING_FAILED = "Failed to embed {name}: {error}"
+EMBEDDING_BATCH_COMPUTE_FAILED = "Failed to embed batch of {count}: {error}"
+CONTEXT_TOKEN_COUNT_FAILED = "Context token count failed: {error}"
NO_SOURCE_FOR = "No source code found for {name}"
EMBEDDINGS_COMPLETE = "Successfully generated {count} semantic embeddings"
EMBEDDING_GENERATION_FAILED = "Failed to generate semantic embeddings: {error}"
EMBEDDING_STORE_FAILED = "Failed to store embedding for {name}: {error}"
+EMBEDDING_STORE_RETRY = "Qdrant upsert failed (attempt {attempt}/{max_attempts}), retrying in {delay:.1f}s: {error}"
+EMBEDDING_BATCH_STORED = "Stored batch of {count} embeddings in Qdrant"
+EMBEDDING_BATCH_FAILED = "Failed to store embedding batch: {error}"
EMBEDDING_SEARCH_FAILED = "Failed to search embeddings: {error}"
-
-# (H) Image logs
-IMAGE_COPIED = "Copied image to temporary path: {path}"
+EMBEDDING_RECONCILE_OK = "Qdrant reconciliation: all {count} expected embeddings found"
+EMBEDDING_RECONCILE_MISSING = "Qdrant reconciliation: {missing} of {expected} embeddings missing (IDs: {sample_ids})"
+EMBEDDING_RECONCILE_FAILED = "Qdrant reconciliation check failed: {error}"
+QDRANT_DELETE_PROJECT = "Deleting {count} Qdrant vectors for project '{project}'"
+QDRANT_DELETE_PROJECT_DONE = "Deleted Qdrant vectors for project '{project}'"
+QDRANT_DELETE_PROJECT_FAILED = (
+ "Failed to delete Qdrant vectors for project '{project}': {error}"
+)
+QDRANT_LOCK_ERROR = (
+ "Failed to open embedded Qdrant at '{path}': {error}. The storage folder is "
+ "locked by another process; look for the '.lock' sentinel inside it. Embedded "
+ "Qdrant allows only one process at a time, so a running MCP server and a CLI "
+ "indexing run cannot share it. Set QDRANT_URL to point at a shared Qdrant "
+ "server for concurrent access."
+)
+EMBEDDING_CACHE_HIT = "Embedding cache hit for {count} snippets"
+EMBEDDING_CACHE_LOADED = "Loaded embedding cache with {count} entries from {path}"
+EMBEDDING_CACHE_SAVE_FAILED = "Failed to save embedding cache to {path}: {error}"
+EMBEDDING_CACHE_LOAD_FAILED = "Failed to load embedding cache from {path}: {error}"
+
+# (H) Multimodal attachment logs
+MULTIMODAL_ATTACHED = "Attached multimodal content: {path}"
+MULTIMODAL_NOT_FOUND = "Multimodal path referenced but not found: {path}"
+MULTIMODAL_READ_FAILED = "Failed to read multimodal file '{path}': {error}"
# (H) Protobuf service logs
PROTOBUF_INIT = "ProtobufFileIngestor initialized to write to: {path}"
@@ -95,10 +132,30 @@
)
CGRIGNORE_READ_FAILED = "Failed to read {path}: {error}"
+CGR_INSTRUCTIONS_LOADED = "Loaded project instructions from {path} ({chars} chars)"
+CGR_INSTRUCTIONS_READ_FAILED = "Failed to read project instructions {path}: {error}"
+
# (H) File watcher logs
WATCHER_ACTIVE = "File watcher is now active."
+WATCHER_DEBOUNCE_ACTIVE = (
+ "File watcher active with debouncing (debounce={debounce}s, max_wait={max_wait}s)"
+)
WATCHER_SKIP_NO_QUERY = "Ingestor does not support querying, skipping real-time update."
CHANGE_DETECTED = "Change detected: {event_type} on {path}. Updating graph."
+CHANGE_DEBOUNCING = (
+ "Change detected: {event_type} on {name} (debouncing for {debounce}s)"
+)
+DEBOUNCE_RESET = "Reset debounce timer for {path}"
+DEBOUNCE_MAX_WAIT = "Max wait ({max_wait}s) exceeded for {path}, processing now"
+DEBOUNCE_SCHEDULED = (
+ "Scheduled update for {path} in {debounce}s (max wait: {remaining}s remaining)"
+)
+DEBOUNCE_PROCESSING = "Processing debounced change: {path}"
+DEBOUNCE_NO_EVENT = "No pending event for {path}, skipping"
+DEBOUNCE_MAX_WAIT_ADJUSTED = (
+ "max_wait ({max_wait}s) is less than debounce ({debounce}s). "
+ "Setting max_wait to debounce value."
+)
DELETION_QUERY = "Ran deletion query for path: {path}"
RECALC_CALLS = "Recalculating all function call relationships for consistency..."
GRAPH_UPDATED = "Graph updated successfully for change in: {name}"
@@ -155,7 +212,8 @@
# (H) Memgraph logs
MG_CONNECTING = "Connecting to Memgraph at {host}:{port}..."
MG_CONNECTED = "Successfully connected to Memgraph."
-MG_EXCEPTION = "An exception occurred: {error}. Flushing remaining items..."
+MG_EXCEPTION = "An exception occurred: {error}. Attempting best-effort flush..."
+MG_FLUSH_ERROR = "Failed to flush during cleanup: {error}"
MG_DISCONNECTED = "\nDisconnected from Memgraph."
MG_CYPHER_ERROR = "!!! Cypher Error: {error}"
MG_CYPHER_QUERY = " Query: {query}"
@@ -177,7 +235,9 @@
"Relationship buffer reached batch size ({size}). Performing incremental flush."
)
MG_NO_CONSTRAINT = "No unique constraint defined for label '{label}'. Skipping flush."
-MG_MISSING_PROP = "Skipping {label} node missing required '{key}' property: {props}"
+MG_MISSING_PROP = (
+ "Skipping {label} node missing required '{key}' property (keys: {prop_keys})"
+)
MG_NODES_FLUSHED = "Flushed {flushed} of {total} buffered nodes."
MG_NODES_SKIPPED = (
"Skipped {count} buffered nodes due to missing identifiers or constraints."
@@ -189,6 +249,18 @@
)
MG_FLUSH_START = "--- Flushing all pending writes to database... ---"
MG_FLUSH_COMPLETE = "--- Flushing complete. ---"
+MG_PARALLEL_FLUSH_NODES = (
+ "Parallel flushing {count} label groups with {workers} workers"
+)
+MG_PARALLEL_FLUSH_RELS = (
+ "Parallel flushing {count} relationship groups with {workers} workers"
+)
+MG_LABEL_FLUSH_ERROR = "Error flushing label group '{label}': {error}"
+MG_REL_FLUSH_ERROR = "Error flushing relationship group '{pattern}': {error}"
+MG_NO_CONN_NODES = "No database connection for label '{label}', skipping flush."
+MG_NO_CONN_RELS = (
+ "No database connection for relationship group '{pattern}', skipping flush."
+)
MG_FETCH_QUERY = "Executing fetch query: {query} with params: {params}"
MG_WRITE_QUERY = "Executing write query: {query} with params: {params}"
MG_EXPORTING = "Exporting graph data..."
@@ -215,6 +287,13 @@
)
TOOL_QUERY_RECEIVED = "[Tool:QueryGraph] Received NL query: '{query}'"
TOOL_QUERY_ERROR = "[Tool:QueryGraph] Error during query execution: {error}"
+TOOL_QUERY_TIMEOUT = (
+ "[Tool:QueryGraph] Query exceeded {timeout:.1f}s and was cancelled: {query}"
+)
+QUERY_RESULTS_TRUNCATED = (
+ "[Tool:QueryGraph] Results truncated: showing {kept} of {total} rows "
+ "({tokens} tokens, limit {max_tokens})"
+)
TOOL_SHELL_EXEC = "Executing shell command: {cmd}"
TOOL_SHELL_RETURN = "Return code: {code}"
TOOL_SHELL_STDOUT = "Stdout: {stdout}"
@@ -224,7 +303,6 @@
"Process already terminated when timeout kill was attempted."
)
TOOL_SHELL_ERROR = "An error occurred while executing command: {error}"
-TOOL_DOC_ANALYZE = "[DocumentAnalyzer] Analyzing '{path}' with question: '{question}'"
# (H) Shell timing log
SHELL_TIMING = "'{func}' executed in {time:.2f}ms"
@@ -276,15 +354,6 @@
SEMANTIC_TOOL_SEARCH = "[Tool:SemanticSearch] Searching for: '{query}'"
SEMANTIC_TOOL_SOURCE = "[Tool:GetFunctionSource] Retrieving source for node ID: {id}"
-# (H) Document analyzer logs
-DOC_COPIED = "Copied external file to: {path}"
-DOC_SUCCESS = "Successfully received analysis for '{path}'."
-DOC_NO_TEXT = "No text found in response: {response}"
-DOC_API_ERROR = "Google GenAI API error for '{path}': {error}"
-DOC_FAILED = "Failed to analyze document '{path}': {error}"
-DOC_RESULT = "[analyze_document] Result type: {type}, content: {preview}..."
-DOC_EXCEPTION = "[analyze_document] Exception during analysis: {error}"
-
# (H) Code retrieval logs
CODE_RETRIEVER_INIT = "CodeRetriever initialized with root: {root}"
CODE_RETRIEVER_SEARCH = "[CodeRetriever] Searching for: {name}"
@@ -295,14 +364,12 @@
FILE_EDITOR_INIT = "FileEditor initialized with root: {root}"
FILE_READER_INIT = "FileReader initialized with root: {root}"
SHELL_COMMANDER_INIT = "ShellCommander initialized with root: {root}"
-DOC_ANALYZER_INIT = "DocumentAnalyzer initialized with root: {root}"
# (H) Tool error logs
FILE_EDITOR_WARN = "[FileEditor] {msg}"
FILE_EDITOR_ERR = "[FileEditor] {msg}"
FILE_EDITOR_ERR_EDIT = "[FileEditor] Error editing file {path}: {error}"
FILE_READER_ERR = "Error reading file {path}: {error}"
-DOC_ANALYZER_API_ERR = "[DocumentAnalyzer] API validation error: {error}"
# (H) File writer logs
FILE_WRITER_INIT = "FileWriter initialized with root: {root}"
@@ -312,18 +379,20 @@
# (H) Error logs (used with logger.error/warning)
UNEXPECTED = "An unexpected error occurred: {error}"
EXPORT_ERROR = "Export error: {error}"
+STATS_ERROR = "Stats error: {error}"
+DEADCODE_SCANNING = "Scanning project '{project_name}' for dead code"
+DEADCODE_ERROR = "Dead code scan error: {error}"
INDEXING_FAILED = "Indexing failed"
PATH_NOT_IN_QUESTION = (
- "Could not find original path in question for replacement: {path}"
+ "Could not locate path token in user message for attachment: {path}"
)
-IMAGE_NOT_FOUND = "Image path found, but does not exist: {path}"
-IMAGE_COPY_FAILED = "Failed to copy image to temporary directory: {error}"
FILE_OUTSIDE_ROOT = "Security risk: Attempted to {action} file outside of project root."
# (H) Call processor logs
CALL_PROCESSING_FILE = "Processing calls in cached AST for: {path}"
CALL_PROCESSING_FAILED = "Failed to process calls in {path}: {error}"
CALL_FOUND_NODES = "Found {count} call nodes in {language} for {caller}"
+CALL_SKIP_CLASS = "Skipping CALLS edge from {caller} to {call_name} (callee is Class node: {callee_qn})"
CALL_FOUND = (
"Found call from {caller} to {call_name} (resolved as {callee_type}:{callee_qn})"
)
@@ -593,6 +662,14 @@
MCP_ERROR_WRITE = "[MCP] Error writing file: {error}"
MCP_LIST_DIR = "[MCP] list_directory: {path}"
MCP_ERROR_LIST_DIR = "[MCP] Error listing directory: {error}"
+MCP_SEMANTIC_NOT_AVAILABLE = (
+ "[MCP] Semantic search not available. Install with: uv sync --extra semantic"
+)
+MCP_UPDATING_REPO = "[MCP] Updating repository at: {path}"
+MCP_ERROR_UPDATING = "[MCP] Error updating repository: {error}"
+MCP_SEMANTIC_SEARCH = "[MCP] semantic_search: {query}"
+MCP_ASK_AGENT = "[MCP] ask_agent: {question}"
+MCP_ASK_AGENT_ERROR = "[MCP] Error running ask_agent: {error}"
# (H) MCP server logs
MCP_SERVER_INFERRED_ROOT = "[GraphCode MCP] Using inferred project root: {path}"
@@ -612,6 +689,35 @@
MCP_SERVER_CONNECTED = "[GraphCode MCP] Connected to Memgraph at {host}:{port}"
MCP_SERVER_FATAL_ERROR = "[GraphCode MCP] Fatal error: {error}"
MCP_SERVER_SHUTDOWN = "[GraphCode MCP] Shutting down server..."
+MCP_HTTP_SERVER_STARTING = "[GraphCode MCP] Starting HTTP server on {host}:{port}..."
+MCP_HTTP_SERVER_READY = (
+ "[GraphCode MCP] HTTP server ready. MCP endpoint: http://{host}:{port}/mcp"
+)
+
+# (H) Incremental update logs
+HASH_CACHE_LOADED = "Loaded hash cache with {count} entries from {path}"
+HASH_CACHE_LOAD_FAILED = "Failed to load hash cache from {path}: {error}"
+HASH_CACHE_SAVED = "Saved hash cache with {count} entries to {path}"
+HASH_CACHE_SAVE_FAILED = "Failed to save hash cache to {path}: {error}"
+PERIODIC_FLUSH = "Periodic flush after {count} files processed"
+INCREMENTAL_SKIPPED = "Skipped {count} unchanged files"
+INCREMENTAL_CHANGED = "Re-indexing {count} changed files"
+INCREMENTAL_DELETED = "Removed state for {count} deleted files"
+INCREMENTAL_FORCE = "Force mode enabled, bypassing hash cache"
+
+# (H) Orphan pruning logs
+PRUNE_START = "--- Pruning orphan nodes from graph ---"
+PRUNE_FOUND = "Found {count} orphan {label} nodes to remove"
+PRUNE_DELETING = "Pruning orphan {label}: {path}"
+PRUNE_COMPLETE = "Pruning complete. Removed {count} orphan nodes."
+PRUNE_SKIP = "No orphan nodes found. Graph is clean."
+FILE_HASH_UNCHANGED = "File unchanged (hash match): {path}"
+FILE_HASH_CHANGED = "File changed (hash mismatch): {path}"
+FILE_HASH_NEW = "New file detected: {path}"
+FILE_UNREADABLE = (
+ "Skipping unreadable file (broken symlink or removed): {path} ({error})"
+)
+INCREMENTAL_UNREADABLE = "Skipped {count} unreadable files (broken symlinks or removed)"
# (H) Exclude prompt logs
EXCLUDE_INVALID_INDEX = "Invalid index: {index} (out of range)"
@@ -621,3 +727,7 @@
MODEL_SWITCHED = "Model switched to: {model}"
MODEL_SWITCH_FAILED = "Failed to switch model: {error}"
MODEL_CURRENT = "Current model: {model}"
+
+# (H) Progress bar logs
+PROGRESS_INDEXING_LABEL = "[bold blue]Indexing files..."
+PROGRESS_FILES_PROCESSED = "{count} processed"
diff --git a/codebase_rag/main.py b/codebase_rag/main.py
index af58a84a4..9bb1ef791 100644
--- a/codebase_rag/main.py
+++ b/codebase_rag/main.py
@@ -3,26 +3,44 @@
import asyncio
import difflib
import json
+import mimetypes
import os
import shlex
import shutil
+import subprocess
import sys
import uuid
from collections import deque
-from collections.abc import Coroutine
+from collections.abc import Callable, Coroutine
+from contextlib import contextmanager
from dataclasses import replace
+from html import escape as html_escape
from pathlib import Path
from typing import TYPE_CHECKING
from loguru import logger
-from prompt_toolkit import prompt
+from prompt_toolkit import PromptSession, prompt
from prompt_toolkit.formatted_text import HTML
from prompt_toolkit.key_binding import KeyBindings
from prompt_toolkit.shortcuts import print_formatted_text
-from pydantic_ai import DeferredToolRequests, DeferredToolResults, ToolDenied
-from rich.markdown import Markdown
+from pydantic_ai import (
+ BinaryContent,
+ DeferredToolRequests,
+ DeferredToolResults,
+ ToolDenied,
+)
+from pydantic_ai.messages import (
+ ModelRequest,
+ ModelResponse,
+ ToolCallPart,
+ ToolReturnPart,
+ UserContent,
+)
+from rich.console import Group
+from rich.live import Live
from rich.panel import Panel
-from rich.prompt import Confirm, Prompt
+from rich.prompt import Prompt
+from rich.spinner import Spinner
from rich.table import Table
from rich.text import Text
@@ -39,7 +57,6 @@
from .tools.code_retrieval import CodeRetriever, create_code_retrieval_tool
from .tools.codebase_query import create_query_tool
from .tools.directory_lister import DirectoryLister, create_directory_lister_tool
-from .tools.document_analyzer import DocumentAnalyzer, create_document_analyzer_tool
from .tools.file_editor import FileEditor, create_file_editor_tool
from .tools.file_reader import FileReader, create_file_reader_tool
from .tools.file_writer import FileWriter, create_file_writer_tool
@@ -57,11 +74,13 @@
ConfirmationToolNames,
CreateFileArgs,
GraphData,
+ QueryJsonOutput,
RawToolArgs,
ReplaceCodeArgs,
ShellCommandArgs,
ToolArgs,
)
+from .utils.rich_markdown import LeftAlignedMarkdown
if TYPE_CHECKING:
from prompt_toolkit.key_binding import KeyPressEvent
@@ -109,6 +128,50 @@ def get_session_context() -> str:
return ""
+def _autowrap_diff_blocks(text: str) -> str:
+ if cs.DIFF_GIT_HEADER not in text:
+ return text
+ lines = text.split("\n")
+ out: list[str] = []
+ in_fence = False
+ in_diff = False
+
+ def is_diff_continuation(line: str) -> bool:
+ if line == "":
+ return True
+ return line.startswith(cs.DIFF_CONTINUATION_PREFIXES)
+
+ for line in lines:
+ if line.startswith(cs.MARKDOWN_FENCE):
+ if in_diff:
+ out.append(cs.MARKDOWN_FENCE)
+ in_diff = False
+ in_fence = not in_fence
+ out.append(line)
+ continue
+ if in_fence:
+ out.append(line)
+ continue
+ if not in_diff and line.startswith(cs.DIFF_GIT_HEADER):
+ out.append(cs.MARKDOWN_FENCE_DIFF)
+ in_diff = True
+ out.append(line)
+ continue
+ if in_diff:
+ if is_diff_continuation(line):
+ out.append(line)
+ else:
+ out.append(cs.MARKDOWN_FENCE)
+ in_diff = False
+ out.append(line)
+ continue
+ out.append(line)
+
+ if in_diff:
+ out.append(cs.MARKDOWN_FENCE)
+ return "\n".join(out)
+
+
def _print_unified_diff(target: str, replacement: str, path: str) -> None:
separator = dim(cs.HORIZONTAL_SEPARATOR)
app_context.console.print(f"\n{cs.UI_DIFF_FILE_HEADER.format(path=path)}")
@@ -216,7 +279,7 @@ def _display_tool_call_diff(
)
-def _process_tool_approvals(
+async def _process_tool_approvals(
requests: DeferredToolRequests,
approval_prompt: str,
denial_default: str,
@@ -228,30 +291,102 @@ def _process_tool_approvals(
tool_args = _to_tool_args(
call.tool_name, RawToolArgs(**call.args_as_dict()), tool_names
)
- app_context.console.print(
- f"\n{cs.UI_TOOL_APPROVAL.format(tool_name=call.tool_name)}"
+ will_prompt = (
+ app_context.session.confirm_edits and not app_context.session.is_yolo()
)
+
+ if will_prompt:
+ app_context.console.print(
+ f"\n{cs.UI_TOOL_APPROVAL.format(tool_name=call.tool_name)}"
+ )
_display_tool_call_diff(call.tool_name, tool_args, tool_names)
- if app_context.session.confirm_edits:
- if Confirm.ask(style(approval_prompt, cs.Color.CYAN)):
- deferred_results.approvals[call.tool_call_id] = True
- else:
- feedback = Prompt.ask(
- cs.UI_FEEDBACK_PROMPT,
- default="",
- )
- denial_msg = feedback.strip() or denial_default
- deferred_results.approvals[call.tool_call_id] = ToolDenied(denial_msg)
- else:
+ if not will_prompt:
+ deferred_results.approvals[call.tool_call_id] = True
+ continue
+
+ if await _confirm_with_toggle(approval_prompt):
+ deferred_results.approvals[call.tool_call_id] = True
+ elif app_context.session.is_yolo():
deferred_results.approvals[call.tool_call_id] = True
+ else:
+ feedback = await _prompt_with_toggle(cs.UI_FEEDBACK_PROMPT)
+ denial_msg = feedback.strip() or denial_default
+ deferred_results.approvals[call.tool_call_id] = ToolDenied(denial_msg)
return deferred_results
+def _approval_keybindings() -> KeyBindings:
+ bindings = KeyBindings()
+
+ @bindings.add(cs.KeyBinding.SHIFT_TAB)
+ def _toggle(event: KeyPressEvent) -> None:
+ app_context.session.cycle_permission_mode()
+ if app_context.session.is_yolo():
+ event.app.exit(result=cs.YES_ANSWER)
+ else:
+ event.app.invalidate()
+
+ @bindings.add(cs.KeyBinding.CTRL_C)
+ def _interrupt(event: KeyPressEvent) -> None:
+ event.app.exit(exception=KeyboardInterrupt)
+
+ return bindings
+
+
+async def _confirm_with_toggle(question: str) -> bool:
+ bindings = _approval_keybindings()
+ prompt_text = HTML(
+ f' [y/n] (Y): '
+ )
+ session: PromptSession[str] = PromptSession()
+ while True:
+ try:
+ answer = await session.prompt_async(
+ prompt_text,
+ key_bindings=bindings,
+ style=ORANGE_STYLE,
+ bottom_toolbar=lambda: _status_bar_label(),
+ refresh_interval=0.5,
+ )
+ except (KeyboardInterrupt, EOFError):
+ return False
+ if app_context.session.is_yolo():
+ return True
+ normalized = (answer or "").strip().lower()
+ if normalized in cs.YES_ANSWERS:
+ return True
+ if normalized in cs.NO_ANSWERS:
+ return False
+
+
+async def _prompt_with_toggle(question: str) -> str:
+ bindings = _approval_keybindings()
+ prompt_text = HTML(
+ f': '
+ )
+ session: PromptSession[str] = PromptSession()
+ try:
+ answer = await session.prompt_async(
+ prompt_text,
+ key_bindings=bindings,
+ style=ORANGE_STYLE,
+ bottom_toolbar=lambda: _status_bar_label(),
+ refresh_interval=0.5,
+ )
+ except (KeyboardInterrupt, EOFError):
+ return ""
+ return answer or ""
+
+
+def _rich_log_sink(message: object) -> None:
+ app_context.console.print(str(message), end="", markup=False, highlight=False)
+
+
def _setup_common_initialization(repo_path: str) -> Path:
logger.remove()
- logger.add(sys.stdout, format=cs.LOG_FORMAT)
+ logger.add(_rich_log_sink, format=cs.LOG_FORMAT, colorize=False)
project_root = Path(repo_path).resolve()
tmp_dir = project_root / cs.TMP_DIR
@@ -262,6 +397,7 @@ def _setup_common_initialization(repo_path: str) -> Path:
tmp_dir.unlink()
tmp_dir.mkdir()
+ app_context.session.target_repo = project_root
return project_root
@@ -385,46 +521,75 @@ async def run_with_cancellation[T](
return CancelledResult(cancelled=True)
+def _cancel_orphaned_tool_calls(message_history: list[ModelMessage]) -> None:
+ if not message_history:
+ return
+ last = message_history[-1]
+ if not isinstance(last, ModelResponse):
+ return
+ tool_calls = [p for p in last.parts if isinstance(p, ToolCallPart)]
+ if not tool_calls:
+ return
+ message_history.append(
+ ModelRequest(
+ parts=[
+ ToolReturnPart(
+ tool_name=p.tool_name,
+ content=cs.MSG_TOOL_CALL_CANCELLED,
+ tool_call_id=p.tool_call_id,
+ )
+ for p in tool_calls
+ ]
+ )
+ )
+
+
async def _run_agent_response_loop(
rag_agent: Agent[None, str | DeferredToolRequests],
message_history: list[ModelMessage],
- question_with_context: str,
+ question_with_context: str | list[UserContent],
config: AgentLoopUI,
tool_names: ConfirmationToolNames,
model_override: Model | None = None,
) -> None:
deferred_results: DeferredToolResults | None = None
+ pending_prompt: str | list[UserContent] | None = question_with_context
while True:
- with app_context.console.status(config.status_message):
+ with _thinking_with_status_bar(config.status_message):
response = await run_with_cancellation(
rag_agent.run(
- question_with_context,
+ pending_prompt,
message_history=message_history,
deferred_tool_results=deferred_results,
model=model_override,
),
)
+ pending_prompt = None
if isinstance(response, CancelledResult):
log_session_event(config.cancelled_log)
app_context.session.cancelled = True
+ _cancel_orphaned_tool_calls(message_history)
break
+ message_history.extend(response.new_messages())
+
if isinstance(response.output, DeferredToolRequests):
- deferred_results = _process_tool_approvals(
+ deferred_results = await _process_tool_approvals(
response.output,
config.approval_prompt,
config.denial_default,
tool_names,
)
- message_history.extend(response.new_messages())
continue
+ asyncio.create_task(_refresh_context_tokens(list(message_history)))
+
output_text = response.output
if not isinstance(output_text, str):
continue
- markdown_response = Markdown(output_text)
+ markdown_response = LeftAlignedMarkdown(_autowrap_diff_blocks(output_text))
app_context.console.print(
Panel(
markdown_response,
@@ -434,35 +599,29 @@ async def _run_agent_response_loop(
)
log_session_event(f"{cs.SESSION_PREFIX_ASSISTANT}{output_text}")
- message_history.extend(response.new_messages())
break
-def _find_image_paths(question: str) -> list[Path]:
+def _find_multimodal_paths(question: str) -> list[Path]:
try:
if os.name == "nt":
- # (H) On Windows, shlex.split with posix=False to preserve backslashes
tokens = shlex.split(question, posix=False)
else:
tokens = shlex.split(question)
except ValueError:
tokens = question.split()
- image_paths: list[Path] = []
+ paths: list[Path] = []
for token in tokens:
- # (H) Strip quotes if they remain (shlex with posix=False might keep some)
token = token.strip("'\"")
- # (H) Check if it looks like an image path
- if token.lower().endswith(cs.IMAGE_EXTENSIONS):
- # (H) On Windows, could be C:\... or \...
- # (H) On POSIX, starts with /
+ if token.lower().endswith(cs.MULTIMODAL_EXTENSIONS):
p = Path(token)
if p.is_absolute() or token.startswith("/") or token.startswith("\\"):
- image_paths.append(p)
- return image_paths
+ paths.append(p)
+ return paths
-def _get_path_variants(path_str: str) -> tuple[str, ...]:
+def _path_variants(path_str: str) -> tuple[str, ...]:
return (
path_str.replace(" ", r"\ "),
f"'{path_str}'",
@@ -471,40 +630,417 @@ def _get_path_variants(path_str: str) -> tuple[str, ...]:
)
-def _replace_path_in_question(question: str, old_path: str, new_path: str) -> str:
- for variant in _get_path_variants(old_path):
- if variant in question:
- return question.replace(variant, new_path)
- logger.warning(ls.PATH_NOT_IN_QUESTION.format(path=old_path))
- return question
+def _guess_media_type(path: Path) -> str:
+ mime, _ = mimetypes.guess_type(str(path))
+ return mime or cs.MIME_TYPE_FALLBACK
-def _handle_chat_images(question: str, project_root: Path) -> str:
- image_files = _find_image_paths(question)
- if not image_files:
+def _build_user_prompt(question: str) -> str | list[UserContent]:
+ paths = _find_multimodal_paths(question)
+ if not paths:
return question
- tmp_dir = project_root / cs.TMP_DIR
- tmp_dir.mkdir(exist_ok=True)
- updated_question = question
-
- for original_path in image_files:
- if not original_path.exists() or not original_path.is_file():
- logger.warning(ls.IMAGE_NOT_FOUND.format(path=original_path))
+ content: list[UserContent] = []
+ remaining = question
+ for path in paths:
+ if not path.exists() or not path.is_file():
+ logger.warning(ls.MULTIMODAL_NOT_FOUND.format(path=path))
continue
-
+ match_token = next(
+ (v for v in _path_variants(str(path)) if v in remaining), None
+ )
+ if match_token is None:
+ logger.warning(ls.PATH_NOT_IN_QUESTION.format(path=path))
+ continue
+ before, _, after = remaining.partition(match_token)
+ if before.strip():
+ content.append(before.rstrip())
try:
- new_path = tmp_dir / f"{uuid.uuid4()}-{original_path.name}"
- shutil.copy(original_path, new_path)
- new_relative = str(new_path.relative_to(project_root))
- updated_question = _replace_path_in_question(
- updated_question, str(original_path), new_relative
+ content.append(
+ BinaryContent(
+ data=path.read_bytes(), media_type=_guess_media_type(path)
+ )
)
- logger.info(ls.IMAGE_COPIED.format(path=new_relative))
+ logger.info(ls.MULTIMODAL_ATTACHED.format(path=path))
except Exception as e:
- logger.error(ls.IMAGE_COPY_FAILED.format(error=e))
+ logger.error(ls.MULTIMODAL_READ_FAILED.format(path=path, error=e))
+ content.append(match_token)
+ remaining = after
+
+ if remaining.strip():
+ content.append(remaining.lstrip())
+
+ return content or question
+
+
+def _permission_mode_label() -> str:
+ return (
+ cs.PERMISSION_MODE_YOLO_LABEL
+ if app_context.session.is_yolo()
+ else cs.PERMISSION_MODE_NORMAL_LABEL
+ )
+
+
+def _git_state() -> tuple[str, bool] | None:
+ repo = app_context.session.target_repo
+ if repo is None or not repo.exists():
+ return None
+ try:
+ result = subprocess.run(
+ ["git", "status", "--porcelain", "--branch"],
+ capture_output=True,
+ text=True,
+ timeout=1.0,
+ check=True,
+ cwd=repo,
+ )
+ except (subprocess.SubprocessError, FileNotFoundError):
+ return None
+ lines = result.stdout.splitlines()
+ if not lines or not lines[0].startswith("## "):
+ return None
+ header = lines[0][3:].split("...", 1)[0].split(" ", 1)[0]
+ if header in ("HEAD", "No"):
+ return None
+ is_dirty = any(line for line in lines[1:])
+ return header, is_dirty
+
+
+def _terminal_columns() -> int:
+ return shutil.get_terminal_size((80, 24)).columns
+
+
+def _format_tokens(n: int) -> str:
+ if n >= 1_000_000:
+ return f"{n / 1_000_000:.1f}M"
+ if n >= 1_000:
+ return f"{n / 1_000:.1f}k"
+ return str(n)
+
+
+def _token_color(pct: float) -> str:
+ if pct >= cs.TOKEN_THRESHOLD_CRITICAL:
+ return cs.TOKEN_COLOR_CRITICAL
+ if pct >= cs.TOKEN_THRESHOLD_WARNING:
+ return cs.TOKEN_COLOR_WARNING
+ return cs.TOKEN_COLOR_OK
+
- return updated_question
+def _token_usage() -> tuple[int, int, float]:
+ try:
+ used = int(app_context.session.context_tokens)
+ except (TypeError, ValueError):
+ used = 0
+ try:
+ model_id = settings.active_orchestrator_config.model_id or ""
+ except Exception:
+ model_id = ""
+ bare = model_id.split(":", 1)[-1]
+ max_ctx = cs.MODEL_CONTEXT_WINDOWS.get(bare, cs.DEFAULT_CONTEXT_WINDOW)
+ pct = (used / max_ctx * 100) if max_ctx > 0 else 0.0
+ return used, max_ctx, pct
+
+
+async def _refresh_context_tokens(messages: list[ModelMessage]) -> None:
+ try:
+ config = settings.active_orchestrator_config
+ except Exception:
+ return
+ if config.provider != cs.Provider.ANTHROPIC or not config.api_key:
+ return
+ try:
+ from .services.anthropic_token_counter import count_anthropic_context
+
+ count = await count_anthropic_context(config.api_key, config.model_id, messages)
+ app_context.session.context_tokens = count
+ except Exception as e:
+ logger.debug(ls.CONTEXT_TOKEN_COUNT_FAILED.format(error=e))
+
+
+def _prime_context_token_counter(system_prompt: str) -> None:
+ if not system_prompt:
+ return
+ from pydantic_ai.messages import ModelRequest, SystemPromptPart
+
+ baseline_messages: list[ModelMessage] = [
+ ModelRequest(parts=[SystemPromptPart(content=system_prompt)])
+ ]
+ asyncio.create_task(_refresh_context_tokens(baseline_messages))
+
+
+def _short_model_id() -> tuple[str, str]:
+ try:
+ orch = settings.active_orchestrator_config.model_id or ""
+ except Exception:
+ orch = ""
+ try:
+ cyph = settings.active_cypher_config.model_id or ""
+ except Exception:
+ cyph = ""
+ return orch.split(":", 1)[-1], cyph.split(":", 1)[-1]
+
+
+def _abbreviated_repo(p: Path | None) -> str:
+ if p is None:
+ return ""
+ try:
+ home = Path.home()
+ return f"~/{p.relative_to(home)}" if p.is_relative_to(home) else str(p)
+ except (ValueError, OSError):
+ return str(p)
+
+
+def _config_segments() -> list[tuple[str, str]]:
+ orch, cyph = _short_model_id()
+ segments: list[tuple[str, str]] = []
+ if orch:
+ segments.append((cs.STATUS_BAR_CONFIG_LABEL_O, orch))
+ if cyph:
+ segments.append((cs.STATUS_BAR_CONFIG_LABEL_C, cyph))
+ segments.append(
+ (
+ cs.STATUS_BAR_CONFIG_LABEL_EDIT,
+ cs.STATUS_BAR_EDIT_ON
+ if app_context.session.confirm_edits
+ else cs.STATUS_BAR_EDIT_OFF,
+ )
+ )
+ segments.append(
+ (
+ cs.STATUS_BAR_CONFIG_LABEL_INSTRUCTIONS,
+ cs.STATUS_BAR_EDIT_ON
+ if app_context.session.load_cgr_instructions
+ else cs.STATUS_BAR_EDIT_OFF,
+ )
+ )
+ repo = _abbreviated_repo(app_context.session.target_repo)
+ if repo:
+ segments.append((cs.STATUS_BAR_CONFIG_LABEL_REPO, repo))
+ return segments
+
+
+def _config_status_html() -> str:
+ parts = [
+ f''
+ f''
+ for label, value in _config_segments()
+ ]
+ return cs.STATUS_BAR_CONFIG_SEPARATOR.join(parts)
+
+
+def _config_status_plain() -> str:
+ parts = [f"{label}:{value}" for label, value in _config_segments()]
+ return cs.STATUS_BAR_CONFIG_SEPARATOR.join(parts)
+
+
+def _config_status_rich() -> Text:
+ line = Text()
+ segments = _config_segments()
+ for i, (label, value) in enumerate(segments):
+ if i > 0:
+ line.append(cs.STATUS_BAR_CONFIG_SEPARATOR, style="dim")
+ line.append(f"{label}:", style=f"bold {cs.STATUS_BAR_CONFIG_LABEL_COLOR}")
+ line.append(value, style=cs.STATUS_BAR_CONFIG_COLOR)
+ return line
+
+
+def _branch_chip_html_and_plain(state: tuple[str, bool] | None) -> tuple[str, str]:
+ if state is None:
+ return "", ""
+ branch, is_dirty = state
+ html_template = (
+ cs.STATUS_BAR_BRANCH_DIRTY_HTML if is_dirty else cs.STATUS_BAR_BRANCH_CLEAN_HTML
+ )
+ plain_template = (
+ cs.STATUS_BAR_BRANCH_DIRTY_PLAIN
+ if is_dirty
+ else cs.STATUS_BAR_BRANCH_CLEAN_PLAIN
+ )
+ return (
+ html_template.format(branch=html_escape(branch)),
+ plain_template.format(branch=branch),
+ )
+
+
+def _branch_chip_rich(state: tuple[str, bool] | None) -> Text:
+ if state is None:
+ return Text()
+ branch, is_dirty = state
+ marker = cs.STATUS_BAR_DIRTY_MARKER if is_dirty else ""
+ chip_style = cs.STATUS_BAR_DIRTY_STYLE if is_dirty else cs.STATUS_BAR_CLEAN_STYLE
+ chip = Text()
+ chip.append(
+ cs.STATUS_BAR_BRANCH_RICH_TEXT.format(branch=branch, marker=marker),
+ style=chip_style,
+ )
+ return chip
+
+
+def _status_bar_label() -> HTML | str:
+ mode = _permission_mode_label()
+ state = _git_state()
+ columns = _terminal_columns()
+ sep_html = (
+ f'"
+ )
+
+ used, max_ctx, pct = _token_usage()
+ used_str = _format_tokens(used)
+ max_str = _format_tokens(max_ctx)
+ pct_str = f"{pct:.1f}%"
+ token_html = cs.STATUS_BAR_TOKEN_HTML.format(
+ color=_token_color(pct),
+ used=used_str,
+ max_ctx=max_str,
+ pct=pct_str,
+ )
+ token_plain = f" {used_str} / {max_str} ({pct_str})"
+ body_html = html_escape(mode) + token_html
+ body_plain = mode + token_plain
+
+ config_html = _config_status_html()
+ config_plain = _config_status_plain()
+ branch_html, branch_plain = _branch_chip_html_and_plain(state)
+
+ config_with_branch_html = config_html
+ config_with_branch_plain = config_plain
+ if branch_html:
+ if config_html:
+ config_with_branch_html = f"{config_html} {branch_html}"
+ config_with_branch_plain = f"{config_plain} {branch_plain}"
+ else:
+ config_with_branch_html = branch_html
+ config_with_branch_plain = branch_plain
+
+ if not config_with_branch_plain:
+ return HTML(f"{sep_html}\n{body_html}")
+ inline_sep = " "
+ if len(body_plain) + len(inline_sep) + len(config_with_branch_plain) <= columns:
+ return HTML(f"{sep_html}\n{body_html}{inline_sep}{config_with_branch_html}")
+ return HTML(f"{sep_html}\n{config_with_branch_html}\n{body_html}")
+
+
+def _rich_status_bar() -> Text:
+ body = Text()
+ body.append(_permission_mode_label(), style="dim")
+ used, max_ctx, pct = _token_usage()
+ body.append(" ")
+ body.append(
+ f"{_format_tokens(used)} / {_format_tokens(max_ctx)} ({pct:.1f}%)",
+ style=_token_color(pct),
+ )
+
+ config_line = _config_status_rich()
+ branch_chip = _branch_chip_rich(_git_state())
+ if config_line.plain and branch_chip.plain:
+ config_line.append(" ")
+ config_line.append_text(branch_chip)
+ elif branch_chip.plain:
+ config_line = branch_chip
+
+ if not config_line.plain:
+ return body
+
+ inline_sep = " "
+ if (
+ len(body.plain) + len(inline_sep) + len(config_line.plain)
+ <= _terminal_columns()
+ ):
+ body.append(inline_sep)
+ body.append_text(config_line)
+ return body
+ return Text("\n").join([config_line, body])
+
+
+@contextmanager
+def _shift_tab_listener():
+ if sys.platform == "win32" or not sys.stdin.isatty():
+ yield
+ return
+ try:
+ import termios
+ except ImportError:
+ yield
+ return
+ fd = sys.stdin.fileno()
+ try:
+ original = termios.tcgetattr(fd)
+ except (termios.error, OSError):
+ yield
+ return
+ try:
+ new_attrs = termios.tcgetattr(fd)
+ new_attrs[3] &= ~(termios.ICANON | termios.ECHO)
+ new_attrs[6][termios.VMIN] = 0
+ new_attrs[6][termios.VTIME] = 0
+ termios.tcsetattr(fd, termios.TCSANOW, new_attrs)
+ loop = asyncio.get_running_loop()
+ buffer = bytearray()
+
+ def on_input() -> None:
+ try:
+ data = os.read(fd, 1024)
+ except OSError:
+ return
+ if not data:
+ return
+ buffer.extend(data)
+ while cs.SHIFT_TAB_ESCAPE in buffer:
+ idx = buffer.index(cs.SHIFT_TAB_ESCAPE)
+ del buffer[idx : idx + len(cs.SHIFT_TAB_ESCAPE)]
+ app_context.session.cycle_permission_mode()
+
+ loop.add_reader(fd, on_input)
+ try:
+ yield
+ finally:
+ try:
+ loop.remove_reader(fd)
+ except Exception:
+ pass
+ finally:
+ try:
+ termios.tcsetattr(fd, termios.TCSADRAIN, original)
+ except (termios.error, OSError):
+ pass
+
+
+@contextmanager
+def _thinking_with_status_bar(message: str):
+ spinner = Spinner(cs.STATUS_BAR_SPINNER, text=Text.from_markup(message))
+ separator = Text(
+ cs.STATUS_BAR_SEPARATOR_CHAR * _terminal_columns(),
+ style=cs.STATUS_BAR_SEPARATOR_COLOR,
+ )
+
+ def render() -> Group:
+ return Group(separator, spinner, _rich_status_bar())
+
+ with (
+ Live(
+ render(),
+ console=app_context.console,
+ refresh_per_second=4,
+ transient=True,
+ ) as live,
+ _shift_tab_listener(),
+ ):
+
+ async def _refresh_bar() -> None:
+ while True:
+ try:
+ live.update(render())
+ await asyncio.sleep(0.25)
+ except asyncio.CancelledError:
+ return
+
+ refresh_task = asyncio.get_running_loop().create_task(_refresh_bar())
+ try:
+ yield live
+ finally:
+ refresh_task.cancel()
def get_multiline_input(prompt_text: str = cs.PROMPT_ASK_QUESTION) -> str:
@@ -514,6 +1050,10 @@ def get_multiline_input(prompt_text: str = cs.PROMPT_ASK_QUESTION) -> str:
def submit(event: KeyPressEvent) -> None:
event.app.exit(result=event.app.current_buffer.text)
+ @bindings.add(cs.KeyBinding.CTRL_E)
+ def submit_ctrl_e(event: KeyPressEvent) -> None:
+ event.app.exit(result=event.app.current_buffer.text)
+
@bindings.add(cs.KeyBinding.ENTER)
def new_line(event: KeyPressEvent) -> None:
event.current_buffer.insert_text("\n")
@@ -522,6 +1062,11 @@ def new_line(event: KeyPressEvent) -> None:
def keyboard_interrupt(event: KeyPressEvent) -> None:
event.app.exit(exception=KeyboardInterrupt)
+ @bindings.add(cs.KeyBinding.SHIFT_TAB)
+ def toggle_permission_mode(event: KeyPressEvent) -> None:
+ app_context.session.cycle_permission_mode()
+ event.app.invalidate()
+
clean_prompt = Text.from_markup(prompt_text).plain
print_formatted_text(
@@ -538,6 +1083,8 @@ def keyboard_interrupt(event: KeyPressEvent) -> None:
key_bindings=bindings,
wrap_lines=True,
style=ORANGE_STYLE,
+ bottom_toolbar=lambda: _status_bar_label(),
+ refresh_interval=0.5,
)
if result is None:
raise EOFError
@@ -664,19 +1211,17 @@ async def _run_interactive_loop(
log_session_event(f"{cs.SESSION_PREFIX_USER}{question}")
if app_context.session.cancelled:
- question_with_context = question + get_session_context()
+ question_text = question + get_session_context()
app_context.session.reset_cancelled()
else:
- question_with_context = question
+ question_text = question
- question_with_context = _handle_chat_images(
- question_with_context, project_root
- )
+ user_prompt: str | list[UserContent] = _build_user_prompt(question_text)
await _run_agent_response_loop(
rag_agent,
message_history,
- question_with_context,
+ user_prompt,
config,
tool_names,
model_override,
@@ -752,6 +1297,8 @@ def connect_memgraph(batch_size: int) -> MemgraphIngestor:
host=settings.MEMGRAPH_HOST,
port=settings.MEMGRAPH_PORT,
batch_size=batch_size,
+ username=settings.MEMGRAPH_USERNAME,
+ password=settings.MEMGRAPH_PASSWORD,
)
@@ -969,8 +1516,10 @@ def _validate_provider_config(role: cs.ModelRole, config: ModelConfig) -> None:
def _initialize_services_and_agent(
- repo_path: str, ingestor: QueryProtocol
-) -> tuple[Agent[None, str | DeferredToolRequests], ConfirmationToolNames]:
+ repo_path: str,
+ ingestor: QueryProtocol,
+ active_projects: list[str] | None = None,
+) -> tuple[Agent[None, str | DeferredToolRequests], ConfirmationToolNames, str]:
_validate_provider_config(
cs.ModelRole.ORCHESTRATOR, settings.active_orchestrator_config
)
@@ -982,10 +1531,11 @@ def _initialize_services_and_agent(
file_writer = FileWriter(project_root=repo_path)
file_editor = FileEditor(project_root=repo_path)
shell_commander = ShellCommander(
- project_root=repo_path, timeout=settings.SHELL_COMMAND_TIMEOUT
+ project_root=repo_path,
+ timeout=settings.SHELL_COMMAND_TIMEOUT,
+ is_yolo=app_context.session.is_yolo,
)
directory_lister = DirectoryLister(project_root=repo_path)
- document_analyzer = DocumentAnalyzer(project_root=repo_path)
query_tool = create_query_tool(ingestor, cypher_generator, app_context.console)
code_tool = create_code_retrieval_tool(code_retriever)
@@ -994,7 +1544,6 @@ def _initialize_services_and_agent(
file_editor_tool = create_file_editor_tool(file_editor)
shell_command_tool = create_shell_command_tool(shell_commander)
directory_lister_tool = create_directory_lister_tool(directory_lister)
- document_analyzer_tool = create_document_analyzer_tool(document_analyzer)
semantic_search_tool = create_semantic_search_tool()
function_source_tool = create_get_function_source_tool()
@@ -1004,7 +1553,7 @@ def _initialize_services_and_agent(
shell_command=shell_command_tool.name,
)
- rag_agent = create_rag_orchestrator(
+ rag_agent, system_prompt = create_rag_orchestrator(
tools=[
query_tool,
code_tool,
@@ -1013,21 +1562,55 @@ def _initialize_services_and_agent(
file_editor_tool,
shell_command_tool,
directory_lister_tool,
- document_analyzer_tool,
semantic_search_tool,
function_source_tool,
- ]
+ ],
+ project_root=Path(repo_path),
+ load_instructions=app_context.session.load_cgr_instructions,
+ active_projects=active_projects,
)
- return rag_agent, confirmation_tool_names
+ return rag_agent, confirmation_tool_names, system_prompt
-async def main_async(repo_path: str, batch_size: int) -> None:
+def main_single_query(
+ repo_path: str,
+ batch_size: int,
+ question: str,
+ active_projects: list[str] | None = None,
+ output_format: cs.QueryFormat = cs.QueryFormat.TABLE,
+) -> None:
+ _setup_common_initialization(repo_path)
+ # (H) Override logger to stderr so stdout is clean for scripted output
+ logger.remove()
+ logger.add(sys.stderr, level=cs.LOG_LEVEL_ERROR, format=cs.LOG_FORMAT)
+
+ with connect_memgraph(batch_size) as ingestor:
+ rag_agent, _, _ = _initialize_services_and_agent(
+ repo_path, ingestor, active_projects=active_projects
+ )
+ response = asyncio.run(rag_agent.run(question, message_history=[]))
+ if output_format == cs.QueryFormat.JSON:
+ payload = QueryJsonOutput(query=question, response=str(response.output))
+ print(json.dumps(payload, ensure_ascii=False)) # noqa: T201
+ else:
+ print(response.output) # noqa: T201
+
+
+async def main_async(
+ repo_path: str,
+ batch_size: int,
+ active_projects: list[str] | None = None,
+ show_config_table: bool = True,
+ pre_chat_sync: Callable[[], None] | None = None,
+ pre_chat_sync_message: str = cs.MSG_SYNCING_KNOWLEDGE_GRAPH,
+) -> None:
project_root = _setup_common_initialization(repo_path)
- table = _create_configuration_table(repo_path)
- app_context.console.print(table)
+ if show_config_table:
+ table = _create_configuration_table(repo_path)
+ app_context.console.print(table)
- with connect_memgraph(batch_size) as ingestor:
+ async with connect_memgraph(batch_size) as ingestor:
app_context.console.print(style(cs.MSG_CONNECTED_MEMGRAPH, cs.Color.GREEN))
app_context.console.print(
Panel(
@@ -1036,10 +1619,26 @@ async def main_async(repo_path: str, batch_size: int) -> None:
)
)
- rag_agent, tool_names = _initialize_services_and_agent(repo_path, ingestor)
+ rag_agent, tool_names, system_prompt = _initialize_services_and_agent(
+ repo_path, ingestor, active_projects=active_projects
+ )
+ _prime_context_token_counter(system_prompt)
+
+ if pre_chat_sync is not None:
+ await _run_pre_chat_sync(pre_chat_sync, pre_chat_sync_message)
+
await run_chat_loop(rag_agent, [], project_root, tool_names)
+async def _run_pre_chat_sync(task: Callable[[], None], message: str) -> None:
+ logger.disable("codebase_rag")
+ try:
+ with _thinking_with_status_bar(message):
+ await asyncio.to_thread(task)
+ finally:
+ logger.enable("codebase_rag")
+
+
async def main_optimize_async(
language: str,
target_repo_path: str,
@@ -1063,12 +1662,13 @@ async def main_optimize_async(
effective_batch_size = settings.resolve_batch_size(batch_size)
- with connect_memgraph(effective_batch_size) as ingestor:
+ async with connect_memgraph(effective_batch_size) as ingestor:
app_context.console.print(style(cs.MSG_CONNECTED_MEMGRAPH, cs.Color.GREEN))
- rag_agent, tool_names = _initialize_services_and_agent(
+ rag_agent, tool_names, system_prompt = _initialize_services_and_agent(
target_repo_path, ingestor
)
+ _prime_context_token_counter(system_prompt)
await run_optimization_loop(
rag_agent, [], project_root, language, tool_names, reference_document
)
diff --git a/codebase_rag/mcp/__init__.py b/codebase_rag/mcp/__init__.py
index 77c80d78a..f3a26b0b7 100644
--- a/codebase_rag/mcp/__init__.py
+++ b/codebase_rag/mcp/__init__.py
@@ -1 +1,2 @@
-from codebase_rag.mcp.server import main as main
+from codebase_rag.mcp.server import serve_http as serve_http
+from codebase_rag.mcp.server import serve_stdio as serve_stdio
diff --git a/codebase_rag/mcp/client.py b/codebase_rag/mcp/client.py
new file mode 100644
index 000000000..b6abb205d
--- /dev/null
+++ b/codebase_rag/mcp/client.py
@@ -0,0 +1,65 @@
+import asyncio
+import io
+import json
+import os
+import sys
+
+import typer
+from mcp import ClientSession
+from mcp.client.stdio import StdioServerParameters, stdio_client
+
+from codebase_rag import constants as cs
+
+app = typer.Typer()
+
+
+async def _query_with_errlog(question: str, errlog: io.TextIOWrapper) -> dict[str, str]:
+ server_params = StdioServerParameters(
+ command=sys.executable,
+ args=["-m", "codebase_rag.cli", "mcp-server"],
+ )
+
+ async with stdio_client(server=server_params, errlog=errlog) as (read, write):
+ async with ClientSession(read, write) as session:
+ await session.initialize()
+ result = await session.call_tool(
+ cs.MCPToolName.ASK_AGENT,
+ {cs.MCPParamName.QUESTION: question},
+ )
+
+ if result.content:
+ response_text = result.content[0].text
+ try:
+ parsed = json.loads(response_text)
+ if isinstance(parsed, dict):
+ return parsed
+ return {"output": str(parsed)}
+ except json.JSONDecodeError:
+ return {"output": response_text}
+ return {"output": "No response from server"}
+
+
+def query_mcp_server(question: str) -> dict[str, str]:
+ with open(os.devnull, "w") as devnull: # noqa: SIM115
+ return asyncio.run(_query_with_errlog(question, devnull))
+
+
+@app.command()
+def main(
+ question: str = typer.Option(
+ ..., "--ask-agent", "-a", help="Question to ask about the codebase"
+ ),
+) -> None:
+ try:
+ result = query_mcp_server(question)
+ if isinstance(result, dict) and "output" in result:
+ print(result["output"]) # noqa: T201
+ else:
+ print(json.dumps(result)) # noqa: T201
+ except Exception as e:
+ print(f"Error: {e}", file=sys.stderr) # noqa: T201
+ sys.exit(1)
+
+
+if __name__ == "__main__":
+ app()
diff --git a/codebase_rag/mcp/server.py b/codebase_rag/mcp/server.py
index 9218a2d93..6f59e4b67 100644
--- a/codebase_rag/mcp/server.py
+++ b/codebase_rag/mcp/server.py
@@ -1,6 +1,8 @@
+import contextlib
import json
import os
import sys
+from collections.abc import Iterator
from pathlib import Path
from loguru import logger
@@ -16,6 +18,7 @@
from codebase_rag.services.graph_service import MemgraphIngestor
from codebase_rag.services.llm import CypherGenerator
from codebase_rag.types_defs import MCPToolArguments
+from codebase_rag.vector_store import close_qdrant_client
def setup_logging() -> None:
@@ -71,6 +74,8 @@ def create_server() -> tuple[Server, MemgraphIngestor]:
host=settings.MEMGRAPH_HOST,
port=settings.MEMGRAPH_PORT,
batch_size=settings.MEMGRAPH_BATCH_SIZE,
+ username=settings.MEMGRAPH_USERNAME,
+ password=settings.MEMGRAPH_PASSWORD,
)
cypher_generator = CypherGenerator()
@@ -135,18 +140,33 @@ async def call_tool(name: str, arguments: MCPToolArguments) -> list[TextContent]
return server, ingestor
-async def main() -> None:
+@contextlib.contextmanager
+def _service_lifecycle(ingestor: MemgraphIngestor) -> Iterator[None]:
+ """Manage shared service lifetimes for the MCP server.
+
+ Opens the Memgraph ingestor connection and guarantees the embedded Qdrant
+ client lock is released on shutdown, so a CLI indexing run can reuse the
+ storage folder once the server stops.
+ """
+ try:
+ with ingestor:
+ logger.info(
+ lg.MCP_SERVER_CONNECTED.format(
+ host=settings.MEMGRAPH_HOST, port=settings.MEMGRAPH_PORT
+ )
+ )
+ yield
+ finally:
+ close_qdrant_client()
+
+
+async def serve_stdio() -> None:
logger.info(lg.MCP_SERVER_STARTING)
server, ingestor = create_server()
logger.info(lg.MCP_SERVER_CREATED)
- with ingestor:
- logger.info(
- lg.MCP_SERVER_CONNECTED.format(
- host=settings.MEMGRAPH_HOST, port=settings.MEMGRAPH_PORT
- )
- )
+ with _service_lifecycle(ingestor):
try:
async with stdio_server() as (read_stream, write_stream):
await server.run(
@@ -159,7 +179,45 @@ async def main() -> None:
logger.info(lg.MCP_SERVER_SHUTDOWN)
+async def serve_http(
+ host: str = settings.MCP_HTTP_HOST,
+ port: int = settings.MCP_HTTP_PORT,
+) -> None:
+ import uvicorn
+ from mcp.server.streamable_http_manager import StreamableHTTPSessionManager
+ from starlette.applications import Starlette
+ from starlette.routing import Mount
+
+ logger.info(lg.MCP_HTTP_SERVER_STARTING.format(host=host, port=port))
+
+ server, ingestor = create_server()
+
+ session_manager = StreamableHTTPSessionManager(
+ app=server,
+ json_response=False,
+ stateless=False,
+ )
+
+ @contextlib.asynccontextmanager
+ async def lifespan(app: Starlette):
+ with _service_lifecycle(ingestor):
+ async with session_manager.run():
+ logger.info(lg.MCP_HTTP_SERVER_READY.format(host=host, port=port))
+ yield
+
+ starlette_app = Starlette(
+ routes=[
+ Mount(settings.MCP_HTTP_ENDPOINT_PATH, app=session_manager.handle_request),
+ ],
+ lifespan=lifespan,
+ )
+
+ config = uvicorn.Config(starlette_app, host=host, port=port, log_level="info")
+ uvicorn_server = uvicorn.Server(config)
+ await uvicorn_server.serve()
+
+
if __name__ == "__main__":
import asyncio
- asyncio.run(main())
+ asyncio.run(serve_stdio())
diff --git a/codebase_rag/mcp/tools.py b/codebase_rag/mcp/tools.py
index 5d1d2f7f5..51ffb7923 100644
--- a/codebase_rag/mcp/tools.py
+++ b/codebase_rag/mcp/tools.py
@@ -1,7 +1,11 @@
+import asyncio
import itertools
+import sys
from pathlib import Path
from loguru import logger
+from pydantic_ai import Agent
+from rich.console import Console
from codebase_rag import constants as cs
from codebase_rag import logs as lg
@@ -10,9 +14,12 @@
from codebase_rag.models import ToolMetadata
from codebase_rag.parser_loader import load_parsers
from codebase_rag.services.graph_service import MemgraphIngestor
-from codebase_rag.services.llm import CypherGenerator
+from codebase_rag.services.llm import CypherGenerator, create_rag_orchestrator
from codebase_rag.tools import tool_descriptions as td
-from codebase_rag.tools.code_retrieval import CodeRetriever, create_code_retrieval_tool
+from codebase_rag.tools.code_retrieval import (
+ CodeRetriever,
+ create_code_retrieval_tool,
+)
from codebase_rag.tools.codebase_query import create_query_tool
from codebase_rag.tools.directory_lister import (
DirectoryLister,
@@ -21,6 +28,7 @@
from codebase_rag.tools.file_editor import FileEditor, create_file_editor_tool
from codebase_rag.tools.file_reader import FileReader, create_file_reader_tool
from codebase_rag.tools.file_writer import FileWriter, create_file_writer_tool
+from codebase_rag.tools.shell_command import ShellCommander, create_shell_command_tool
from codebase_rag.types_defs import (
CodeSnippetResultDict,
DeleteProjectErrorResult,
@@ -35,6 +43,8 @@
MCPToolSchema,
QueryResultDict,
)
+from codebase_rag.utils.dependencies import has_semantic_dependencies
+from codebase_rag.vector_store import delete_project_embeddings
class MCPToolsRegistry:
@@ -47,6 +57,7 @@ def __init__(
self.project_root = project_root
self.ingestor = ingestor
self.cypher_gen = cypher_gen
+ self._ingestor_lock = asyncio.Lock()
self.parsers, self.queries = load_parsers()
@@ -55,9 +66,11 @@ def __init__(
self.file_reader = FileReader(project_root=project_root)
self.file_writer = FileWriter(project_root=project_root)
self.directory_lister = DirectoryLister(project_root=project_root)
+ self.shell_commander = ShellCommander(project_root=project_root)
+ stderr_console = Console(file=sys.stderr, width=None, force_terminal=True)
self._query_tool = create_query_tool(
- ingestor=ingestor, cypher_gen=cypher_gen, console=None
+ ingestor=ingestor, cypher_gen=cypher_gen, console=stderr_console
)
self._code_tool = create_code_retrieval_tool(code_retriever=self.code_retriever)
self._file_editor_tool = create_file_editor_tool(file_editor=self.file_editor)
@@ -66,6 +79,24 @@ def __init__(
self._directory_lister_tool = create_directory_lister_tool(
directory_lister=self.directory_lister
)
+ self._shell_command_tool = create_shell_command_tool(
+ shell_commander=self.shell_commander
+ )
+
+ self._rag_agent: Agent | None = None
+
+ self._semantic_search_tool = None
+ self._semantic_search_available = False
+
+ if has_semantic_dependencies():
+ from codebase_rag.tools.semantic_search import (
+ create_semantic_search_tool,
+ )
+
+ self._semantic_search_tool = create_semantic_search_tool()
+ self._semantic_search_available = True
+ else:
+ logger.info(lg.MCP_SEMANTIC_NOT_AVAILABLE)
self._tools: dict[str, ToolMetadata] = {
cs.MCPToolName.LIST_PROJECTS: ToolMetadata(
@@ -122,6 +153,17 @@ def __init__(
handler=self.index_repository,
returns_json=False,
),
+ cs.MCPToolName.UPDATE_REPOSITORY: ToolMetadata(
+ name=cs.MCPToolName.UPDATE_REPOSITORY,
+ description=td.MCP_TOOLS[cs.MCPToolName.UPDATE_REPOSITORY],
+ input_schema=MCPInputSchema(
+ type=cs.MCPSchemaType.OBJECT,
+ properties={},
+ required=[],
+ ),
+ handler=self.update_repository,
+ returns_json=False,
+ ),
cs.MCPToolName.QUERY_CODE_GRAPH: ToolMetadata(
name=cs.MCPToolName.QUERY_CODE_GRAPH,
description=td.MCP_TOOLS[cs.MCPToolName.QUERY_CODE_GRAPH],
@@ -247,33 +289,122 @@ def __init__(
returns_json=False,
),
}
+ if self._semantic_search_available:
+ self._tools[cs.MCPToolName.SEMANTIC_SEARCH] = ToolMetadata(
+ name=cs.MCPToolName.SEMANTIC_SEARCH,
+ description=td.MCP_TOOLS[cs.MCPToolName.SEMANTIC_SEARCH],
+ input_schema=MCPInputSchema(
+ type=cs.MCPSchemaType.OBJECT,
+ properties={
+ cs.MCPParamName.NATURAL_LANGUAGE_QUERY: MCPInputSchemaProperty(
+ type=cs.MCPSchemaType.STRING,
+ description=td.MCP_PARAM_NATURAL_LANGUAGE_QUERY,
+ ),
+ cs.MCPParamName.TOP_K: MCPInputSchemaProperty(
+ type=cs.MCPSchemaType.INTEGER,
+ description=td.MCP_PARAM_TOP_K,
+ default=5,
+ ),
+ },
+ required=[cs.MCPParamName.NATURAL_LANGUAGE_QUERY],
+ ),
+ handler=self.semantic_search,
+ returns_json=False,
+ )
+
+ self._tools[cs.MCPToolName.ASK_AGENT] = ToolMetadata(
+ name=cs.MCPToolName.ASK_AGENT,
+ description=td.MCP_TOOLS[cs.MCPToolName.ASK_AGENT],
+ input_schema=MCPInputSchema(
+ type=cs.MCPSchemaType.OBJECT,
+ properties={
+ cs.MCPParamName.QUESTION: MCPInputSchemaProperty(
+ type=cs.MCPSchemaType.STRING,
+ description=td.MCP_PARAM_QUESTION,
+ )
+ },
+ required=[cs.MCPParamName.QUESTION],
+ ),
+ handler=self.ask_agent,
+ returns_json=True,
+ )
+
+ @property
+ def rag_agent(self) -> Agent:
+ if self._rag_agent is None:
+ from codebase_rag.tools.semantic_search import (
+ create_get_function_source_tool,
+ )
+
+ tools = [
+ self._query_tool,
+ self._code_tool,
+ self._file_reader_tool,
+ self._file_writer_tool,
+ self._file_editor_tool,
+ self._shell_command_tool,
+ self._directory_lister_tool,
+ create_get_function_source_tool(),
+ ]
+ if self._semantic_search_tool is not None:
+ tools.append(self._semantic_search_tool)
+ self._rag_agent, _ = create_rag_orchestrator(
+ tools=tools, project_root=Path(self.project_root)
+ )
+ return self._rag_agent
+
+ # (H) Setter allows tests to inject a mock agent without triggering LLM init
+ @rag_agent.setter
+ def rag_agent(self, value: Agent) -> None:
+ self._rag_agent = value
async def list_projects(self) -> ListProjectsResult:
logger.info(lg.MCP_LISTING_PROJECTS)
try:
- projects = self.ingestor.list_projects()
+ projects = await asyncio.to_thread(self.ingestor.list_projects)
return ListProjectsSuccessResult(projects=projects, count=len(projects))
except Exception as e:
logger.error(lg.MCP_ERROR_LIST_PROJECTS.format(error=e))
return ListProjectsErrorResult(error=str(e), projects=[], count=0)
+ def _get_project_node_ids(self, project_name: str) -> list[int]:
+ rows = self.ingestor.fetch_all(
+ cs.CYPHER_QUERY_PROJECT_NODE_IDS,
+ {cs.KEY_PROJECT_NAME: project_name},
+ )
+ result: list[int] = []
+ for row in rows:
+ node_id = row.get(cs.KEY_NODE_ID)
+ if isinstance(node_id, int):
+ result.append(node_id)
+ return result
+
+ def _cleanup_project_embeddings(self, project_name: str) -> None:
+ node_ids = self._get_project_node_ids(project_name)
+ delete_project_embeddings(project_name, node_ids)
+
+ def _delete_project_sync(self, project_name: str) -> DeleteProjectResult:
+ projects = self.ingestor.list_projects()
+ if project_name not in projects:
+ return DeleteProjectErrorResult(
+ success=False,
+ error=te.MCP_PROJECT_NOT_FOUND.format(
+ project_name=project_name, projects=projects
+ ),
+ )
+ self._cleanup_project_embeddings(project_name)
+ self.ingestor.delete_project(project_name)
+ return DeleteProjectSuccessResult(
+ success=True,
+ project=project_name,
+ message=cs.MCP_PROJECT_DELETED.format(project_name=project_name),
+ )
+
async def delete_project(self, project_name: str) -> DeleteProjectResult:
logger.info(lg.MCP_DELETING_PROJECT.format(project_name=project_name))
try:
- projects = self.ingestor.list_projects()
- if project_name not in projects:
- return DeleteProjectErrorResult(
- success=False,
- error=te.MCP_PROJECT_NOT_FOUND.format(
- project_name=project_name, projects=projects
- ),
- )
- self.ingestor.delete_project(project_name)
- return DeleteProjectSuccessResult(
- success=True,
- project=project_name,
- message=cs.MCP_PROJECT_DELETED.format(project_name=project_name),
- )
+ async with self._ingestor_lock:
+ return await asyncio.to_thread(self._delete_project_sync, project_name)
except Exception as e:
logger.error(lg.MCP_ERROR_DELETE_PROJECT.format(error=e))
return DeleteProjectErrorResult(success=False, error=str(e))
@@ -283,34 +414,88 @@ async def wipe_database(self, confirm: bool) -> str:
return cs.MCP_WIPE_CANCELLED
logger.warning(lg.MCP_WIPING_DATABASE)
try:
- self.ingestor.clean_database()
+ async with self._ingestor_lock:
+ await asyncio.to_thread(self.ingestor.clean_database)
return cs.MCP_WIPE_SUCCESS
except Exception as e:
logger.error(lg.MCP_ERROR_WIPE.format(error=e))
return cs.MCP_WIPE_ERROR.format(error=e)
+ def _index_repository_sync(self) -> str:
+ project_name = Path(self.project_root).resolve().name
+ logger.info(lg.MCP_CLEARING_PROJECT.format(project_name=project_name))
+ self._cleanup_project_embeddings(project_name)
+ self.ingestor.delete_project(project_name)
+
+ self.ingestor.ensure_constraints()
+ self.ingestor.flush_all()
+
+ updater = GraphUpdater(
+ ingestor=self.ingestor,
+ repo_path=Path(self.project_root),
+ parsers=self.parsers,
+ queries=self.queries,
+ project_name=project_name,
+ )
+ updater.run()
+ self.ingestor.flush_all()
+
+ return cs.MCP_INDEX_SUCCESS_PROJECT.format(
+ path=self.project_root, project_name=project_name
+ )
+
async def index_repository(self) -> str:
logger.info(lg.MCP_INDEXING_REPO.format(path=self.project_root))
- project_name = Path(self.project_root).resolve().name
try:
- logger.info(lg.MCP_CLEARING_PROJECT.format(project_name=project_name))
- self.ingestor.delete_project(project_name)
-
- updater = GraphUpdater(
- ingestor=self.ingestor,
- repo_path=Path(self.project_root),
- parsers=self.parsers,
- queries=self.queries,
- )
- updater.run()
-
- return cs.MCP_INDEX_SUCCESS_PROJECT.format(
- path=self.project_root, project_name=project_name
- )
+ async with self._ingestor_lock:
+ return await asyncio.to_thread(self._index_repository_sync)
except Exception as e:
logger.error(lg.MCP_ERROR_INDEXING.format(error=e))
return cs.MCP_INDEX_ERROR.format(error=e)
+ def _update_repository_sync(self) -> str:
+ project_name = Path(self.project_root).resolve().name
+
+ self.ingestor.ensure_constraints()
+ self.ingestor.flush_all()
+
+ updater = GraphUpdater(
+ ingestor=self.ingestor,
+ repo_path=Path(self.project_root),
+ parsers=self.parsers,
+ queries=self.queries,
+ project_name=project_name,
+ )
+ updater.run()
+ self.ingestor.flush_all()
+ return cs.MCP_UPDATE_SUCCESS.format(path=self.project_root)
+
+ async def update_repository(self) -> str:
+ logger.info(lg.MCP_UPDATING_REPO.format(path=self.project_root))
+ try:
+ async with self._ingestor_lock:
+ return await asyncio.to_thread(self._update_repository_sync)
+ except Exception as e:
+ logger.error(lg.MCP_ERROR_UPDATING.format(error=e))
+ return cs.MCP_UPDATE_ERROR.format(error=e)
+
+ async def semantic_search(self, natural_language_query: str, top_k: int = 5) -> str:
+ assert self._semantic_search_tool is not None
+ logger.info(lg.MCP_SEMANTIC_SEARCH.format(query=natural_language_query))
+ result = await self._semantic_search_tool.function(
+ query=natural_language_query, top_k=top_k
+ )
+ return str(result)
+
+ async def ask_agent(self, question: str) -> dict[str, str]:
+ logger.info(lg.MCP_ASK_AGENT.format(question=question))
+ try:
+ response = await self.rag_agent.run(question, message_history=[])
+ return {"output": str(response.output)}
+ except Exception as e:
+ logger.error(lg.MCP_ASK_AGENT_ERROR.format(error=e))
+ return {"error": cs.MCP_ASK_AGENT_ERROR.format(error=e)}
+
async def query_code_graph(self, natural_language_query: str) -> QueryResultDict:
logger.info(lg.MCP_QUERY_CODE_GRAPH.format(query=natural_language_query))
try:
diff --git a/codebase_rag/models.py b/codebase_rag/models.py
index e189dbde0..763371a16 100644
--- a/codebase_rag/models.py
+++ b/codebase_rag/models.py
@@ -5,7 +5,7 @@
from rich.console import Console
-from .constants import SupportedLanguage
+from .constants import PermissionMode, SupportedLanguage
from .types_defs import MCPHandlerType, MCPInputSchema, PropertyValue
if TYPE_CHECKING:
@@ -15,12 +15,27 @@
@dataclass
class SessionState:
confirm_edits: bool = True
+ load_cgr_instructions: bool = True
log_file: Path | None = None
cancelled: bool = False
+ permission_mode: PermissionMode = PermissionMode.NORMAL
+ context_tokens: int = 0
+ target_repo: Path | None = None
def reset_cancelled(self) -> None:
self.cancelled = False
+ def is_yolo(self) -> bool:
+ return self.permission_mode == PermissionMode.YOLO
+
+ def cycle_permission_mode(self) -> PermissionMode:
+ self.permission_mode = (
+ PermissionMode.YOLO
+ if self.permission_mode == PermissionMode.NORMAL
+ else PermissionMode.NORMAL
+ )
+ return self.permission_mode
+
def _default_console() -> Console:
return Console(width=None, force_terminal=True)
diff --git a/codebase_rag/parser_loader.py b/codebase_rag/parser_loader.py
index 69ddabda3..6e79353ce 100644
--- a/codebase_rag/parser_loader.py
+++ b/codebase_rag/parser_loader.py
@@ -33,7 +33,7 @@ def _try_load_from_submodule(lang_name: cs.SupportedLanguage) -> LanguageLoader:
setup_py_path = submodule_path / cs.SETUP_PY
if setup_py_path.exists():
- logger.debug(ls.BUILDING_BINDINGS.format(lang=lang_name))
+ logger.debug(ls.BUILDING_BINDINGS, lang=lang_name)
result = subprocess.run(
[sys.executable, cs.SETUP_PY, cs.BUILD_EXT_CMD, cs.INPLACE_FLAG],
check=False,
@@ -44,14 +44,15 @@ def _try_load_from_submodule(lang_name: cs.SupportedLanguage) -> LanguageLoader:
if result.returncode != 0:
logger.debug(
- ls.BUILD_FAILED.format(
- lang=lang_name, stdout=result.stdout, stderr=result.stderr
- )
+ ls.BUILD_FAILED,
+ lang=lang_name,
+ stdout=result.stdout,
+ stderr=result.stderr,
)
return None
- logger.debug(ls.BUILD_SUCCESS.format(lang=lang_name))
+ logger.debug(ls.BUILD_SUCCESS, lang=lang_name)
- logger.debug(ls.IMPORTING_MODULE.format(module=module_name))
+ logger.debug(ls.IMPORTING_MODULE, module=module_name)
module = importlib.import_module(module_name)
language_attrs: list[str] = [
@@ -63,21 +64,19 @@ def _try_load_from_submodule(lang_name: cs.SupportedLanguage) -> LanguageLoader:
for attr_name in language_attrs:
if hasattr(module, attr_name):
logger.debug(
- ls.LOADED_FROM_SUBMODULE.format(lang=lang_name, attr=attr_name)
+ ls.LOADED_FROM_SUBMODULE, lang=lang_name, attr=attr_name
)
loader: LanguageLoader = getattr(module, attr_name)
return loader
- logger.debug(
- ls.NO_LANG_ATTR.format(module=module_name, available=dir(module))
- )
+ logger.debug(ls.NO_LANG_ATTR, module=module_name, available=dir(module))
finally:
if python_bindings_str in sys.path:
sys.path.remove(python_bindings_str)
except Exception as e:
- logger.debug(ls.SUBMODULE_LOAD_FAILED.format(lang=lang_name, error=e))
+ logger.debug(ls.SUBMODULE_LOAD_FAILED, lang=lang_name, error=e)
return None
@@ -137,6 +136,12 @@ def _import_language_loaders() -> dict[cs.SupportedLanguage, LanguageLoader]:
cs.QUERY_LANGUAGE,
cs.SupportedLanguage.JAVA,
),
+ LanguageImport(
+ cs.SupportedLanguage.C,
+ cs.TreeSitterModule.C,
+ cs.QUERY_LANGUAGE,
+ cs.SupportedLanguage.C,
+ ),
LanguageImport(
cs.SupportedLanguage.CPP,
cs.TreeSitterModule.CPP,
@@ -149,6 +154,12 @@ def _import_language_loaders() -> dict[cs.SupportedLanguage, LanguageLoader]:
cs.QUERY_LANGUAGE,
cs.SupportedLanguage.LUA,
),
+ LanguageImport(
+ cs.SupportedLanguage.PHP,
+ cs.TreeSitterModule.PHP,
+ cs.LANG_ATTR_PHP,
+ cs.SupportedLanguage.PHP,
+ ),
]
loaders: dict[cs.SupportedLanguage, LanguageLoader] = {
@@ -215,10 +226,14 @@ def _create_locals_query(
try:
return Query(language, locals_pattern)
except Exception as e:
- logger.debug(ls.LOCALS_QUERY_FAILED.format(lang=lang_name, error=e))
+ logger.debug(ls.LOCALS_QUERY_FAILED, lang=lang_name, error=e)
return None
+COMBINED_FUNC_CLASS_QUERIES: dict[cs.SupportedLanguage, Query | None] = {}
+COMBINED_FUNC_CLASS_IMPORT_QUERIES: dict[cs.SupportedLanguage, Query | None] = {}
+
+
def _create_language_queries(
language: Language,
parser: Parser,
@@ -236,6 +251,22 @@ def _create_language_queries(
)
combined_import_patterns = _build_combined_import_pattern(lang_config)
+ combined_fc_pattern = f"{function_patterns} {class_patterns}".strip()
+ try:
+ COMBINED_FUNC_CLASS_QUERIES[lang_name] = (
+ Query(language, combined_fc_pattern) if combined_fc_pattern else None
+ )
+ except Exception:
+ COMBINED_FUNC_CLASS_QUERIES[lang_name] = None
+
+ combined_fci_pattern = f"{function_patterns} {class_patterns} {combined_import_patterns} {call_patterns}".strip()
+ try:
+ COMBINED_FUNC_CLASS_IMPORT_QUERIES[lang_name] = (
+ Query(language, combined_fci_pattern) if combined_fci_pattern else None
+ )
+ except Exception:
+ COMBINED_FUNC_CLASS_IMPORT_QUERIES[lang_name] = None
+
return LanguageQueries(
functions=_create_optional_query(language, function_patterns),
classes=_create_optional_query(language, class_patterns),
@@ -256,7 +287,7 @@ def _process_language(
) -> bool:
lang_lib = LANGUAGE_LIBRARIES.get(lang_name)
if not lang_lib:
- logger.debug(ls.LIB_NOT_AVAILABLE.format(lang=lang_name))
+ logger.debug(ls.LIB_NOT_AVAILABLE, lang=lang_name)
return False
try:
diff --git a/codebase_rag/parsers/call_processor.py b/codebase_rag/parsers/call_processor.py
index 0e53cbe73..3d459c2a4 100644
--- a/codebase_rag/parsers/call_processor.py
+++ b/codebase_rag/parsers/call_processor.py
@@ -1,6 +1,9 @@
from __future__ import annotations
+from bisect import bisect_left, bisect_right
+from collections import defaultdict
from pathlib import Path
+from typing import NamedTuple
from loguru import logger
from tree_sitter import Node, QueryCursor
@@ -8,16 +11,61 @@
from .. import constants as cs
from .. import logs as ls
from ..language_spec import LanguageSpec
+from ..parser_loader import COMBINED_FUNC_CLASS_QUERIES
from ..services import IngestorProtocol
from ..types_defs import FunctionRegistryTrieProtocol, LanguageQueries
+from ..utils.path_utils import cached_relative_path
from .call_resolver import CallResolver
from .cpp import utils as cpp_utils
from .import_processor import ImportProcessor
from .type_inference import TypeInferenceEngine
-from .utils import get_function_captures, is_method_node
+from .utils import (
+ get_function_captures,
+ is_method_node,
+ python_parameter_names,
+ safe_decode_text,
+ sorted_captures,
+)
+
+
+class _CallableFlowArg(NamedTuple):
+ # (H) One call-site argument that may carry a callable: bound either to a concrete
+ # (H) function (source_concrete) or to a parameter of the caller (source_caller +
+ # (H) source_param), keyed to the callee parameter by position or keyword.
+ callee_qn: str
+ position: int
+ keyword: str
+ source_concrete: str
+ source_caller: str
+ source_param: str
+
+
+_TYPED_LANGUAGES = frozenset(
+ {
+ cs.SupportedLanguage.PYTHON,
+ cs.SupportedLanguage.JS,
+ cs.SupportedLanguage.TS,
+ cs.SupportedLanguage.JAVA,
+ cs.SupportedLanguage.LUA,
+ }
+)
+
+# (H) C and C++ share the function_definition/declarator shape, so the callee
+# (H) name lives in a nested declarator (no `name` field). Both need the libclang
+# (H) declarator-aware extractor rather than a plain child_by_field_name("name").
+_C_FAMILY_LANGUAGES = frozenset({cs.SupportedLanguage.C, cs.SupportedLanguage.CPP})
class CallProcessor:
+ __slots__ = (
+ "ingestor",
+ "repo_path",
+ "project_name",
+ "_resolver",
+ "_flow_param_names",
+ "_flow_args",
+ )
+
def __init__(
self,
ingestor: IngestorProtocol,
@@ -38,6 +86,10 @@ def __init__(
type_inference=type_inference,
class_inheritance=class_inheritance,
)
+ # (H) Inter-procedural callable-parameter flow: ordered params per function and
+ # (H) the per-call-site argument bindings, resolved to a fixpoint in finalize.
+ self._flow_param_names: dict[str, list[str]] = {}
+ self._flow_args: list[_CallableFlowArg] = []
def _get_node_name(self, node: Node, field: str = cs.FIELD_NAME) -> str | None:
name_node = node.child_by_field_name(field)
@@ -46,31 +98,299 @@ def _get_node_name(self, node: Node, field: str = cs.FIELD_NAME) -> str | None:
text = name_node.text
return None if text is None else text.decode(cs.ENCODING_UTF8)
+ def _collect_all_call_nodes(
+ self,
+ root_node: Node,
+ language: cs.SupportedLanguage,
+ queries: dict[cs.SupportedLanguage, LanguageQueries],
+ ) -> tuple[list[Node], list[int]]:
+ calls_query = queries[language].get(cs.QUERY_CALLS)
+ if not calls_query:
+ return [], []
+ cursor = QueryCursor(calls_query)
+ captures = sorted_captures(cursor, root_node)
+ call_nodes = captures.get(cs.CAPTURE_CALL, [])
+ call_starts = [n.start_byte for n in call_nodes]
+ return call_nodes, call_starts
+
+ def _filter_calls_in_node(
+ self,
+ all_call_nodes: list[Node],
+ call_starts: list[int],
+ container: Node,
+ ) -> list[Node]:
+ start = container.start_byte
+ end = container.end_byte
+ lo = bisect_left(call_starts, start)
+ hi = bisect_right(call_starts, end)
+ return [n for n in all_call_nodes[lo:hi] if n.end_byte <= end]
+
+ def _filter_top_level_calls(
+ self,
+ all_call_nodes: list[Node],
+ call_starts: list[int],
+ func_nodes: list[Node],
+ ) -> list[Node]:
+ # (H) Calls inside a function's BODY belong to that function, not the
+ # (H) module; only genuine top-level calls are module-attributed. The body
+ # (H) (not the whole node) is the boundary so def-time calls in the
+ # (H) signature -- default args like `def f(x=make_default())` and
+ # (H) decorators -- run at module load and stay module-attributed. A node
+ # (H) with no body is not a real function scope (e.g. a file-scope
+ # (H) declaration `int x = top();` that the grammar captures as a
+ # (H) function); its calls run at load time, so it excludes nothing.
+ nested_starts: set[int] = set()
+ for func_node in func_nodes:
+ body = func_node.child_by_field_name(cs.FIELD_BODY)
+ if body is None:
+ continue
+ for call in self._filter_calls_in_node(all_call_nodes, call_starts, body):
+ nested_starts.add(call.start_byte)
+ return [c for c in all_call_nodes if c.start_byte not in nested_starts]
+
+ def _bare_decorator_name(self, decorator_node: Node) -> str | None:
+ # (H) A bare decorator `@task` / `@pkg.deco` (no call parens) is not a
+ # (H) `call` node, so the normal call pass misses it even though applying
+ # (H) it runs `task(func)` at module load. A call decorator `@deco(...)`
+ # (H) IS a call node and is already captured, so skip it here.
+ named = decorator_node.named_children
+ if not named:
+ return None
+ expr = named[0]
+ if expr.type in (cs.TS_IDENTIFIER, cs.TS_ATTRIBUTE) and expr.text is not None:
+ return expr.text.decode(cs.ENCODING_UTF8)
+ return None
+
+ def _runs_at_module_load(self, node: Node) -> bool:
+ # (H) A definition runs at module load only when it is at module or
+ # (H) class-body scope; nested inside a function body it runs at that
+ # (H) function's call time, so its decorator is not a module-load call.
+ ancestor = node.parent
+ while ancestor is not None:
+ if ancestor.type == cs.TS_PY_FUNCTION_DEFINITION:
+ return False
+ ancestor = ancestor.parent
+ return True
+
+ def _ingest_decorator_calls(
+ self,
+ nodes: list[Node],
+ module_qn: str,
+ root_node: Node,
+ lang_config: LanguageSpec,
+ ) -> None:
+ # (H) Emit `(Module)->decorator` CALLS for bare decorators on functions,
+ # (H) methods, AND classes: the decoration executes at module-load time,
+ # (H) so the module is the caller. Only first-party callables get an edge.
+ resolver = self._resolver
+ ensure_rel = self.ingestor.ensure_relationship_batch
+ qn_key = cs.KEY_QUALIFIED_NAME
+ module_spec = (cs.NodeLabel.MODULE, qn_key, module_qn)
+ callable_labels = (cs.NodeLabel.FUNCTION, cs.NodeLabel.METHOD)
+ alias_map: dict[str, str] | None = None
+ for node in nodes:
+ parent = node.parent
+ if parent is None or parent.type != cs.TS_PY_DECORATED_DEFINITION:
+ continue
+ if not self._runs_at_module_load(parent):
+ continue
+ for child in parent.children:
+ if child.type != cs.TS_PY_DECORATOR:
+ continue
+ name = self._bare_decorator_name(child)
+ if not name:
+ continue
+ callee = resolver.resolve_function_call(name, module_qn)
+ if not callee and cs.SEPARATOR_DOT not in name:
+ # (H) `@alias` where `alias = task` still calls task at load;
+ # (H) reuse the local-alias fallback the call pass uses.
+ if alias_map is None:
+ alias_map = self._build_local_alias_map(
+ root_node, lang_config, module_qn
+ )
+ if (rhs := alias_map.get(name)) is not None:
+ callee = resolver.resolve_function_call(rhs, module_qn)
+ if callee and callee[0] in callable_labels:
+ ensure_rel(
+ module_spec,
+ cs.RelationshipType.CALLS,
+ (callee[0], qn_key, callee[1]),
+ )
+
+ def _module_qn(self, relative_path: Path, file_name: str) -> str:
+ if file_name in (cs.INIT_PY, cs.MOD_RS):
+ return cs.SEPARATOR_DOT.join(
+ [self.project_name] + list(relative_path.parent.parts)
+ )
+ return cs.SEPARATOR_DOT.join(
+ [self.project_name] + list(relative_path.with_suffix("").parts)
+ )
+
+ def collect_callable_field_bindings(
+ self,
+ file_path: Path,
+ root_node: Node,
+ language: cs.SupportedLanguage,
+ queries: dict[cs.SupportedLanguage, LanguageQueries],
+ func_class_captures_cache: dict[Path, dict] | None = None,
+ ) -> None:
+ # (H) Pre-pass: record which functions are bound to a class's callable
+ # (H) fields (FQNSpec(get_name=_python_get_name, ...)). Runs before call
+ # (H) resolution so a field invocation can resolve regardless of which
+ # (H) file the construction site lives in. Keyword bindings only;
+ # (H) positional callable args would need declared field order.
+ if language != cs.SupportedLanguage.PYTHON:
+ return
+ try:
+ module_qn = self._module_qn(
+ cached_relative_path(file_path, self.repo_path), file_path.name
+ )
+ if (
+ func_class_captures_cache is not None
+ and file_path in func_class_captures_cache
+ ):
+ call_nodes = func_class_captures_cache[file_path].get(cs.CAPTURE_CALL)
+ else:
+ call_nodes = None
+ if call_nodes is None:
+ call_nodes, _ = self._collect_all_call_nodes(
+ root_node, language, queries
+ )
+ resolver = self._resolver
+ registry = resolver.function_registry
+ callable_labels = (cs.NodeLabel.FUNCTION, cs.NodeLabel.METHOD)
+ for call_node in call_nodes:
+ _positional, keyword = self._parse_call_arguments(call_node)
+ if not keyword:
+ continue
+ name = self._get_call_target_name(call_node)
+ if not name:
+ continue
+ callee = resolver.resolve_function_call(name, module_qn)
+ if not callee or callee[0] != cs.NodeLabel.CLASS:
+ continue
+ for field, value_node in keyword.items():
+ if not (value_text := safe_decode_text(value_node)):
+ continue
+ bound = resolver.resolve_function_call(value_text, module_qn)
+ if bound and bound[0] in callable_labels and bound[1] in registry:
+ resolver.record_callable_field_binding(
+ callee[1], field, bound[1]
+ )
+ except Exception as e:
+ logger.error(ls.CALL_PROCESSING_FAILED, path=file_path, error=e)
+
def process_calls_in_file(
self,
file_path: Path,
root_node: Node,
language: cs.SupportedLanguage,
queries: dict[cs.SupportedLanguage, LanguageQueries],
+ func_class_captures_cache: dict[Path, dict] | None = None,
) -> None:
- relative_path = file_path.relative_to(self.repo_path)
- logger.debug(ls.CALL_PROCESSING_FILE.format(path=relative_path))
+ relative_path = cached_relative_path(file_path, self.repo_path)
+ logger.debug(ls.CALL_PROCESSING_FILE, path=relative_path)
try:
- module_qn = cs.SEPARATOR_DOT.join(
- [self.project_name] + list(relative_path.with_suffix("").parts)
- )
- if file_path.name in (cs.INIT_PY, cs.MOD_RS):
- module_qn = cs.SEPARATOR_DOT.join(
- [self.project_name] + list(relative_path.parent.parts)
+ module_qn = self._module_qn(relative_path, file_path.name)
+
+ call_name_cache: dict[int, str | None] = {}
+
+ if (
+ func_class_captures_cache is not None
+ and file_path in func_class_captures_cache
+ ):
+ combined_captures = func_class_captures_cache[file_path]
+ else:
+ combined_query = COMBINED_FUNC_CLASS_QUERIES.get(language)
+ if combined_query:
+ cursor = QueryCursor(combined_query)
+ combined_captures = sorted_captures(cursor, root_node)
+ else:
+ combined_captures = {}
+
+ cached_calls = combined_captures.get(cs.CAPTURE_CALL)
+ if cached_calls is not None:
+ all_call_nodes = cached_calls
+ call_starts: list[int] | None = None
+ else:
+ all_call_nodes, call_starts = self._collect_all_call_nodes(
+ root_node, language, queries
)
- self._process_calls_in_functions(root_node, module_qn, language, queries)
- self._process_calls_in_classes(root_node, module_qn, language, queries)
- self._process_module_level_calls(root_node, module_qn, language, queries)
+ sorted_func_nodes = combined_captures.get(cs.CAPTURE_FUNCTION)
+ if sorted_func_nodes or combined_captures.get(cs.CAPTURE_CLASS):
+ if cached_calls is not None:
+ call_starts = [n.start_byte for n in all_call_nodes]
+ func_node_starts = (
+ [n.start_byte for n in sorted_func_nodes]
+ if sorted_func_nodes
+ else None
+ )
+ else:
+ call_starts = None
+ func_node_starts = None
+
+ self._process_calls_in_functions(
+ root_node,
+ module_qn,
+ language,
+ queries,
+ all_call_nodes,
+ call_starts,
+ call_name_cache=call_name_cache,
+ combined_captures=combined_captures or None,
+ )
+ # (H) Bare decorators (`@task`) are not call nodes; emit their
+ # (H) module-load CALLS before the empty-`all_call_nodes` early return,
+ # (H) since a file may have decorators but no other calls. Classes can
+ # (H) be decorated too, so include captured class nodes.
+ if language == cs.SupportedLanguage.PYTHON:
+ decorator_targets = list(sorted_func_nodes or [])
+ if combined_captures and (
+ class_nodes := combined_captures.get(cs.CAPTURE_CLASS)
+ ):
+ decorator_targets.extend(class_nodes)
+ if decorator_targets:
+ self._ingest_decorator_calls(
+ decorator_targets,
+ module_qn,
+ root_node,
+ queries[language][cs.QUERY_CONFIG],
+ )
+ if not all_call_nodes:
+ return
+ self._process_calls_in_classes(
+ root_node,
+ module_qn,
+ language,
+ queries,
+ all_call_nodes,
+ call_starts,
+ call_name_cache=call_name_cache,
+ combined_captures=combined_captures,
+ sorted_func_nodes=sorted_func_nodes,
+ func_node_starts=func_node_starts,
+ )
+ if sorted_func_nodes and call_starts is not None:
+ module_calls = self._filter_top_level_calls(
+ all_call_nodes, call_starts, sorted_func_nodes
+ )
+ else:
+ module_calls = all_call_nodes
+ self._ingest_function_calls(
+ root_node,
+ module_qn,
+ cs.NodeLabel.MODULE,
+ module_qn,
+ language,
+ queries,
+ call_nodes=module_calls,
+ call_name_cache=call_name_cache,
+ )
except Exception as e:
- logger.error(ls.CALL_PROCESSING_FAILED.format(path=file_path, error=e))
+ logger.error(ls.CALL_PROCESSING_FAILED, path=file_path, error=e)
def _process_calls_in_functions(
self,
@@ -78,28 +398,68 @@ def _process_calls_in_functions(
module_qn: str,
language: cs.SupportedLanguage,
queries: dict[cs.SupportedLanguage, LanguageQueries],
+ all_call_nodes: list[Node] | None = None,
+ call_starts: list[int] | None = None,
+ call_name_cache: dict[int, str | None] | None = None,
+ combined_captures: dict[str, list[Node]] | None = None,
) -> None:
- result = get_function_captures(root_node, language, queries)
- if not result:
- return
-
- lang_config, captures = result
- func_nodes = captures.get(cs.CAPTURE_FUNCTION, [])
+ if combined_captures is not None:
+ lang_config = queries[language][cs.QUERY_CONFIG]
+ func_nodes = combined_captures.get(cs.CAPTURE_FUNCTION, [])
+ has_classes = bool(combined_captures.get(cs.CAPTURE_CLASS))
+ else:
+ result = get_function_captures(root_node, language, queries)
+ if not result:
+ return
+ lang_config, captures = result
+ func_nodes = captures.get(cs.CAPTURE_FUNCTION, [])
+ has_classes = bool(captures.get(cs.CAPTURE_CLASS))
for func_node in func_nodes:
- if not isinstance(func_node, Node):
- continue
- if self._is_method(func_node, lang_config):
+ if has_classes and self._is_method(func_node, lang_config):
continue
- if language == cs.SupportedLanguage.CPP:
+ if language in _C_FAMILY_LANGUAGES:
func_name = cpp_utils.extract_function_name(func_node)
else:
func_name = self._get_node_name(func_node)
if not func_name:
continue
+ # (H) An out-of-line C++ method definition (`Ret Class::method() {...}`
+ # (H) at namespace/file scope) is bound by the definition pass to its
+ # (H) class node (qn `class_qn.method`). Attribute its body's calls to
+ # (H) that method node, not a phantom module-rooted free-function qn,
+ # (H) so the CALLS edges join to a real node.
+ if language == cs.SupportedLanguage.CPP and (
+ bound := self._cpp_out_of_class_method_caller(
+ func_node, func_name, module_qn
+ )
+ ):
+ caller_qn, class_qn = bound
+ filtered = (
+ self._filter_calls_in_node(all_call_nodes, call_starts, func_node)
+ if all_call_nodes is not None and call_starts is not None
+ else None
+ )
+ self._ingest_function_calls(
+ func_node,
+ caller_qn,
+ cs.NodeLabel.METHOD,
+ module_qn,
+ language,
+ queries,
+ class_qn,
+ call_nodes=filtered,
+ call_name_cache=call_name_cache,
+ )
+ continue
if func_qn := self._build_nested_qualified_name(
func_node, module_qn, func_name, lang_config
):
+ filtered = (
+ self._filter_calls_in_node(all_call_nodes, call_starts, func_node)
+ if all_call_nodes is not None and call_starts is not None
+ else None
+ )
self._ingest_function_calls(
func_node,
func_qn,
@@ -107,8 +467,34 @@ def _process_calls_in_functions(
module_qn,
language,
queries,
+ call_nodes=filtered,
+ call_name_cache=call_name_cache,
)
+ def _cpp_out_of_class_method_caller(
+ self, func_node: Node, method_name: str, module_qn: str
+ ) -> tuple[str, str] | None:
+ # (H) Resolve an out-of-line C++ method definition to its (method_qn,
+ # (H) class_qn), mirroring the definition pass's class binding. The leaf
+ # (H) class name resolves the class across files (header-declared classes);
+ # (H) `endswith(normalized)` guards against a leaf collision binding to the
+ # (H) wrong class, and the registry membership check ensures the method node
+ # (H) actually exists before overriding the default attribution.
+ if not cpp_utils.is_out_of_class_method_definition(func_node):
+ return None
+ class_name = cpp_utils.extract_class_name_from_out_of_class_method(func_node)
+ if not class_name:
+ return None
+ normalized = class_name.replace(cs.SEPARATOR_DOUBLE_COLON, cs.SEPARATOR_DOT)
+ leaf = normalized.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+ class_qn = self._resolver._resolve_class_name(leaf, module_qn)
+ if not class_qn or not class_qn.endswith(normalized):
+ return None
+ caller_qn = f"{class_qn}{cs.SEPARATOR_DOT}{method_name}"
+ if caller_qn in self._resolver.function_registry:
+ return caller_qn, class_qn
+ return None
+
def _get_rust_impl_class_name(self, class_node: Node) -> str | None:
class_name = self._get_node_name(class_node, cs.FIELD_TYPE)
if class_name:
@@ -136,20 +522,40 @@ def _process_methods_in_class(
module_qn: str,
language: cs.SupportedLanguage,
queries: dict[cs.SupportedLanguage, LanguageQueries],
+ all_call_nodes: list[Node] | None = None,
+ call_starts: list[int] | None = None,
+ call_name_cache: dict[int, str | None] | None = None,
+ sorted_func_nodes: list[Node] | None = None,
+ func_node_starts: list[int] | None = None,
) -> None:
- method_query = queries[language][cs.QUERY_FUNCTIONS]
- if not method_query:
- return
- method_cursor = QueryCursor(method_query)
- method_captures = method_cursor.captures(body_node)
- method_nodes = method_captures.get(cs.CAPTURE_FUNCTION, [])
+ if sorted_func_nodes is not None and func_node_starts is not None:
+ body_start = body_node.start_byte
+ body_end = body_node.end_byte
+ lo = bisect_left(func_node_starts, body_start)
+ hi = bisect_right(func_node_starts, body_end)
+ method_nodes = [
+ n for n in sorted_func_nodes[lo:hi] if n.end_byte <= body_end
+ ]
+ else:
+ method_query = queries[language][cs.QUERY_FUNCTIONS]
+ if not method_query:
+ return
+ method_cursor = QueryCursor(method_query)
+ method_captures = sorted_captures(method_cursor, body_node)
+ method_nodes = method_captures.get(cs.CAPTURE_FUNCTION, [])
for method_node in method_nodes:
- if not isinstance(method_node, Node):
- continue
- method_name = self._get_node_name(method_node)
+ if language in _C_FAMILY_LANGUAGES:
+ method_name = cpp_utils.extract_function_name(method_node)
+ else:
+ method_name = self._get_node_name(method_node)
if not method_name:
continue
method_qn = f"{class_qn}{cs.SEPARATOR_DOT}{method_name}"
+ filtered = (
+ self._filter_calls_in_node(all_call_nodes, call_starts, method_node)
+ if all_call_nodes is not None and call_starts is not None
+ else None
+ )
self._ingest_function_calls(
method_node,
method_qn,
@@ -158,6 +564,8 @@ def _process_methods_in_class(
language,
queries,
class_qn,
+ call_nodes=filtered,
+ call_name_cache=call_name_cache,
)
def _process_calls_in_classes(
@@ -166,38 +574,47 @@ def _process_calls_in_classes(
module_qn: str,
language: cs.SupportedLanguage,
queries: dict[cs.SupportedLanguage, LanguageQueries],
+ all_call_nodes: list[Node] | None = None,
+ call_starts: list[int] | None = None,
+ call_name_cache: dict[int, str | None] | None = None,
+ combined_captures: dict[str, list] | None = None,
+ sorted_func_nodes: list[Node] | None = None,
+ func_node_starts: list[int] | None = None,
) -> None:
- query = queries[language][cs.QUERY_CLASSES]
- if not query:
- return
- cursor = QueryCursor(query)
- captures = cursor.captures(root_node)
- class_nodes = captures.get(cs.CAPTURE_CLASS, [])
+ if combined_captures is not None:
+ class_nodes = combined_captures.get(cs.CAPTURE_CLASS, [])
+ else:
+ query = queries[language][cs.QUERY_CLASSES]
+ if not query:
+ return
+ cursor = QueryCursor(query)
+ captures = sorted_captures(cursor, root_node)
+ class_nodes = captures.get(cs.CAPTURE_CLASS, [])
for class_node in class_nodes:
- if not isinstance(class_node, Node):
- continue
class_name = self._get_class_name_for_node(class_node, language)
if not class_name:
continue
class_qn = f"{module_qn}{cs.SEPARATOR_DOT}{class_name}"
if body_node := class_node.child_by_field_name(cs.FIELD_BODY):
self._process_methods_in_class(
- body_node, class_qn, module_qn, language, queries
+ body_node,
+ class_qn,
+ module_qn,
+ language,
+ queries,
+ all_call_nodes,
+ call_starts,
+ call_name_cache=call_name_cache,
+ sorted_func_nodes=sorted_func_nodes,
+ func_node_starts=func_node_starts,
)
- def _process_module_level_calls(
- self,
- root_node: Node,
- module_qn: str,
- language: cs.SupportedLanguage,
- queries: dict[cs.SupportedLanguage, LanguageQueries],
- ) -> None:
- self._ingest_function_calls(
- root_node, module_qn, cs.NodeLabel.MODULE, module_qn, language, queries
- )
-
def _get_call_target_name(self, call_node: Node) -> str | None:
+ # (H) A macro-internal call (Rust `name(args)` inside a token_tree) is
+ # (H) captured as the bare identifier node; its text is the callee name.
+ if call_node.type == cs.TS_IDENTIFIER and call_node.text is not None:
+ return call_node.text.decode(cs.ENCODING_UTF8)
if func_child := call_node.child_by_field_name(cs.TS_FIELD_FUNCTION):
match func_child.type:
case (
@@ -208,11 +625,16 @@ def _get_call_target_name(self, call_node: Node) -> str | None:
| cs.TS_SCOPED_IDENTIFIER
):
if func_child.text is not None:
- return str(func_child.text.decode(cs.ENCODING_UTF8))
+ return func_child.text.decode(cs.ENCODING_UTF8)
+ case cs.TS_GENERIC_FUNCTION:
+ # (H) turbofish: unwrap to the underlying callee identifier
+ inner = func_child.child_by_field_name(cs.TS_FIELD_FUNCTION)
+ if inner and inner.text:
+ return inner.text.decode(cs.ENCODING_UTF8)
case cs.TS_CPP_FIELD_EXPRESSION:
field_node = func_child.child_by_field_name(cs.FIELD_FIELD)
if field_node and field_node.text:
- return str(field_node.text.decode(cs.ENCODING_UTF8))
+ return field_node.text.decode(cs.ENCODING_UTF8)
case cs.TS_PARENTHESIZED_EXPRESSION:
return self._get_iife_target_name(func_child)
@@ -230,15 +652,15 @@ def _get_call_target_name(self, call_node: Node) -> str | None:
object_node = call_node.child_by_field_name(cs.FIELD_OBJECT)
name_node = call_node.child_by_field_name(cs.FIELD_NAME)
if name_node and name_node.text:
- method_name = str(name_node.text.decode(cs.ENCODING_UTF8))
+ method_name = name_node.text.decode(cs.ENCODING_UTF8)
if not object_node or not object_node.text:
return method_name
- object_text = str(object_node.text.decode(cs.ENCODING_UTF8))
+ object_text = object_node.text.decode(cs.ENCODING_UTF8)
return f"{object_text}{cs.SEPARATOR_DOT}{method_name}"
if name_node := call_node.child_by_field_name(cs.FIELD_NAME):
if name_node.text is not None:
- return str(name_node.text.decode(cs.ENCODING_UTF8))
+ return name_node.text.decode(cs.ENCODING_UTF8)
return None
@@ -260,70 +682,774 @@ def _ingest_function_calls(
language: cs.SupportedLanguage,
queries: dict[cs.SupportedLanguage, LanguageQueries],
class_context: str | None = None,
+ call_nodes: list[Node] | None = None,
+ call_name_cache: dict[int, str | None] | None = None,
) -> None:
- calls_query = queries[language].get(cs.QUERY_CALLS)
- if not calls_query:
- return
+ if language in _TYPED_LANGUAGES:
+ local_var_types = (
+ self._resolver.type_inference.build_local_variable_type_map(
+ caller_node, module_qn, language
+ )
+ )
+ else:
+ local_var_types = None
- local_var_types = self._resolver.type_inference.build_local_variable_type_map(
- caller_node, module_qn, language
- )
+ caller_spec = (caller_type, cs.KEY_QUALIFIED_NAME, caller_qn)
- cursor = QueryCursor(calls_query)
- captures = cursor.captures(caller_node)
- call_nodes = captures.get(cs.CAPTURE_CALL, [])
+ caller_params: frozenset[str] = frozenset()
+ if language == cs.SupportedLanguage.PYTHON:
+ ordered_params = python_parameter_names(caller_node)
+ self._flow_param_names[caller_qn] = ordered_params
+ caller_params = frozenset(ordered_params)
- logger.debug(
- ls.CALL_FOUND_NODES.format(
- count=len(call_nodes), language=language, caller=caller_qn
+ # (H) Runs independently of call_nodes: a getter access is an attribute, not
+ # (H) a call, so callers that read a property but make no other call must
+ # (H) still reach this pass before the early return below.
+ if language == cs.SupportedLanguage.PYTHON and (
+ prop_names := self._resolver.function_registry.property_names()
+ ):
+ self._ingest_property_accesses(
+ caller_node,
+ caller_spec,
+ caller_qn,
+ module_qn,
+ local_var_types,
+ class_context,
+ queries[language][cs.QUERY_CONFIG],
+ prop_names,
)
- )
- for call_node in call_nodes:
- if not isinstance(call_node, Node):
- continue
+ # (H) Operator syntax (k in r, r[k], r[k]=v, len(r)) dispatches to dunder
+ # (H) methods; emit those edges when the operand is a first-party type.
+ if language == cs.SupportedLanguage.PYTHON:
+ self._ingest_operator_dispatch_calls(
+ caller_node, caller_spec, module_qn, local_var_types
+ )
+
+ if call_nodes is None:
+ calls_query = queries[language].get(cs.QUERY_CALLS)
+ if not calls_query:
+ return
+ cursor = QueryCursor(calls_query)
+ captures = sorted_captures(cursor, caller_node)
+ call_nodes = captures.get(cs.CAPTURE_CALL, [])
+
+ if not call_nodes:
+ return
- # (H) tree-sitter finds ALL call nodes including nested; no recursive processing needed
+ is_java = language == cs.SupportedLanguage.JAVA
+ is_js_ts = language in (cs.SupportedLanguage.JS, cs.SupportedLanguage.TS)
+ is_cpp = language == cs.SupportedLanguage.CPP
+ method_invocation_type = cs.TS_METHOD_INVOCATION
+ resolver = self._resolver
+ resolve_func = resolver.resolve_function_call
+ resolve_builtin = resolver.resolve_builtin_call if is_js_ts else None
+ resolve_cpp_op = resolver.resolve_cpp_operator_call if is_cpp else None
+ get_target = self._get_call_target_name
+ class_label = cs.NodeLabel.CLASS
+ ensure_rel = self.ingestor.ensure_relationship_batch
+ calls_rel = cs.RelationshipType.CALLS
+ qn_key = cs.KEY_QUALIFIED_NAME
+ _id = id
+ is_python = language == cs.SupportedLanguage.PYTHON
+ alias_map: dict[str, str] | None = None
- call_name = self._get_call_target_name(call_node)
+ for call_node in call_nodes:
+ node_id = _id(call_node)
+ if call_name_cache is not None and node_id in call_name_cache:
+ call_name = call_name_cache[node_id]
+ else:
+ call_name = get_target(call_node)
+ if call_name_cache is not None:
+ call_name_cache[node_id] = call_name
if not call_name:
continue
- if (
- language == cs.SupportedLanguage.JAVA
- and call_node.type == cs.TS_METHOD_INVOCATION
- ):
- callee_info = self._resolver.resolve_java_method_call(
+ if is_java and call_node.type == method_invocation_type:
+ callee_info = resolver.resolve_java_method_call(
call_node, module_qn, local_var_types
)
else:
- callee_info = self._resolver.resolve_function_call(
+ callee_info = resolve_func(
call_name, module_qn, local_var_types, class_context
)
- if callee_info:
- callee_type, callee_qn = callee_info
- elif builtin_info := self._resolver.resolve_builtin_call(call_name):
- callee_type, callee_qn = builtin_info
- elif operator_info := self._resolver.resolve_cpp_operator_call(
- call_name, module_qn
+ if not callee_info and resolve_builtin is not None:
+ callee_info = resolve_builtin(call_name)
+ if not callee_info and resolve_cpp_op is not None:
+ callee_info = resolve_cpp_op(call_name, module_qn)
+ if not callee_info and is_python and cs.SEPARATOR_DOT not in call_name:
+ # (H) A bare name that resolves to nothing may be a local alias of a
+ # (H) callable (do = self._start; do()). Resolve the assignment's
+ # (H) right-hand side and treat the alias call as a call to it.
+ if alias_map is None:
+ alias_map = self._build_local_alias_map(
+ caller_node, queries[language][cs.QUERY_CONFIG], module_qn
+ )
+ if (rhs := alias_map.get(call_name)) is not None:
+ callee_info = resolve_func(
+ rhs, module_qn, local_var_types, class_context
+ )
+
+ if not callee_info and is_python and cs.SEPARATOR_DOT in call_name:
+ # (H) recv.field(...) where field is a callable struct field:
+ # (H) resolve to the functions bound to it at construction sites.
+ self._ingest_callable_field_calls(
+ call_name, caller_spec, local_var_types, ensure_rel
+ )
+
+ if is_python and call_name.rsplit(cs.SEPARATOR_DOT, 1)[-1] in (
+ cs.HIGHER_ORDER_BUILTINS
+ ):
+ # (H) sorted(xs, key=f) and friends invoke f synchronously in this
+ # (H) frame, so the trace attributes the call to the enclosing fn.
+ self._ingest_higher_order_builtin_calls(
+ call_node,
+ caller_spec,
+ module_qn,
+ local_var_types,
+ class_context,
+ resolve_func,
+ ensure_rel,
+ )
+
+ if not callee_info:
+ continue
+
+ callee_type, callee_qn = callee_info
+
+ if is_python:
+ self._collect_callable_flow(
+ call_node,
+ callee_qn,
+ caller_qn,
+ caller_params,
+ module_qn,
+ local_var_types,
+ class_context,
+ )
+
+ if is_python and (
+ dispatch_targets := resolver.protocol_dispatch_targets(callee_qn)
):
- callee_type, callee_qn = operator_info
+ # (H) The call resolved to a Protocol stub; the stub never runs, so emit
+ # (H) edges to the method on every conformer instead of the stub.
+ for conformer_type, conformer_qn in dispatch_targets:
+ for target_qn in resolver.function_registry.variants(conformer_qn):
+ ensure_rel(
+ caller_spec,
+ calls_rel,
+ (conformer_type, qn_key, target_qn),
+ )
+ continue
+
+ if is_python:
+ # (H) f(...) invoked through a parameter: the edge runs from the
+ # (H) callee to whatever each call site binds to that parameter.
+ self._ingest_callable_param_calls(
+ call_node,
+ callee_type,
+ callee_qn,
+ module_qn,
+ local_var_types,
+ class_context,
+ resolve_func,
+ ensure_rel,
+ )
+
+ if callee_type == class_label:
+ # (H) Record construction as INSTANTIATES -> the class node (keeps
+ # (H) CALLS function/method-only). When the class defines __init__,
+ # (H) ALSO redirect a CALLS edge to it (the constructor runs); when
+ # (H) it does not (dataclass/NamedTuple/pydantic), INSTANTIATES is
+ # (H) the only edge.
+ for class_variant in resolver.function_registry.variants(callee_qn):
+ ensure_rel(
+ caller_spec,
+ cs.RelationshipType.INSTANTIATES,
+ (class_label, qn_key, class_variant),
+ )
+ init_qn = f"{callee_qn}{cs.SEPARATOR_DOT}{cs.PY_METHOD_INIT}"
+ if init_qn not in resolver.function_registry:
+ continue
+ callee_type = cs.NodeLabel.METHOD
+ callee_qn = init_qn
+
+ for target_qn in resolver.function_registry.variants(callee_qn):
+ ensure_rel(
+ caller_spec,
+ calls_rel,
+ (callee_type, qn_key, target_qn),
+ )
+
+ def _ingest_operator_dispatch_calls(
+ self,
+ caller_node: Node,
+ caller_spec: tuple[str, str, str],
+ module_qn: str,
+ local_var_types: dict[str, str] | None,
+ ) -> None:
+ boundary = (cs.TS_PY_FUNCTION_DEFINITION, cs.TS_PY_CLASS_DEFINITION)
+ stack: list[Node] = list(caller_node.children)
+ while stack:
+ node = stack.pop()
+ if node.type in boundary:
+ continue
+ match node.type:
+ case cs.TS_PY_SUBSCRIPT:
+ parent = node.parent
+ left = (
+ parent.child_by_field_name(cs.TS_FIELD_LEFT)
+ if parent is not None and parent.type == cs.TS_PY_ASSIGNMENT
+ else None
+ )
+ is_write = left is not None and left.id == node.id
+ self._emit_operator_dunder(
+ node.child_by_field_name(cs.FIELD_VALUE),
+ cs.PY_DUNDER_SETITEM if is_write else cs.PY_DUNDER_GETITEM,
+ caller_spec,
+ module_qn,
+ local_var_types,
+ )
+ case cs.TS_PY_COMPARISON_OPERATOR:
+ operators = node.child_by_field_name(cs.TS_FIELD_OPERATORS)
+ if (
+ operators is not None
+ and (op_text := safe_decode_text(operators))
+ and cs.PY_OP_IN in op_text.split()
+ and node.named_children
+ ):
+ self._emit_operator_dunder(
+ node.named_children[-1],
+ cs.PY_DUNDER_CONTAINS,
+ caller_spec,
+ module_qn,
+ local_var_types,
+ )
+ case cs.TS_PY_CALL:
+ func = node.child_by_field_name(cs.TS_FIELD_FUNCTION)
+ args = node.child_by_field_name(cs.FIELD_ARGUMENTS)
+ if (
+ func is not None
+ and safe_decode_text(func) == cs.PY_BUILTIN_LEN
+ and args is not None
+ and len(args.named_children) == 1
+ ):
+ self._emit_operator_dunder(
+ args.named_children[0],
+ cs.PY_DUNDER_LEN,
+ caller_spec,
+ module_qn,
+ local_var_types,
+ )
+ case cs.TS_PY_BOOLEAN_OPERATOR:
+ self._emit_truthiness(
+ node.child_by_field_name(cs.TS_FIELD_LEFT),
+ caller_spec,
+ module_qn,
+ local_var_types,
+ )
+ self._emit_truthiness(
+ node.child_by_field_name(cs.TS_FIELD_RIGHT),
+ caller_spec,
+ module_qn,
+ local_var_types,
+ )
+ case cs.TS_PY_NOT_OPERATOR:
+ self._emit_truthiness(
+ node.child_by_field_name(cs.TS_FIELD_ARGUMENT),
+ caller_spec,
+ module_qn,
+ local_var_types,
+ )
+ case (
+ cs.TS_PY_IF_STATEMENT
+ | cs.TS_PY_WHILE_STATEMENT
+ | cs.TS_PY_ELIF_CLAUSE
+ | cs.TS_PY_CONDITIONAL_EXPRESSION
+ ):
+ # (H) A bare object as a condition is tested for truthiness; nested
+ # (H) boolean/not operators are handled when the walk reaches them.
+ self._emit_truthiness(
+ node.child_by_field_name(cs.TS_FIELD_CONDITION),
+ caller_spec,
+ module_qn,
+ local_var_types,
+ )
+ stack.extend(node.children)
+
+ def _emit_truthiness(
+ self,
+ operand: Node | None,
+ caller_spec: tuple[str, str, str],
+ module_qn: str,
+ local_var_types: dict[str, str] | None,
+ ) -> None:
+ # (H) Truthiness of an object calls __bool__ if defined, else __len__. Only a
+ # (H) bare name/attribute operand names an object (a comparison/call is already
+ # (H) a bool and is handled elsewhere); try __bool__ first, then __len__.
+ if operand is None or operand.type not in (
+ cs.TS_PY_IDENTIFIER,
+ cs.TS_PY_ATTRIBUTE,
+ ):
+ return
+ for dunder in (cs.PY_DUNDER_BOOL, cs.PY_DUNDER_LEN):
+ if self._emit_operator_dunder(
+ operand, dunder, caller_spec, module_qn, local_var_types
+ ):
+ return
+
+ def _emit_operator_dunder(
+ self,
+ operand: Node | None,
+ dunder: str,
+ caller_spec: tuple[str, str, str],
+ module_qn: str,
+ local_var_types: dict[str, str] | None,
+ ) -> bool:
+ # (H) Resolve the implied .__dunder__ call; resolution only succeeds
+ # (H) for a first-party class that defines the dunder, so builtin containers
+ # (H) (dict/list) yield no edge. Restrict to simple attribute/name operands.
+ # (H) Returns whether an edge was emitted (truthiness tries __bool__ then __len__).
+ if operand is None or not (operand_text := safe_decode_text(operand)):
+ return False
+ if any(ch in operand_text for ch in cs.PY_OPERAND_REJECT_CHARS):
+ return False
+ targets = self._resolver.operator_dunder_targets(
+ operand_text, dunder, module_qn, local_var_types
+ )
+ if not targets:
+ return False
+ for callee_type, callee_qn in targets:
+ for target_qn in self._resolver.function_registry.variants(callee_qn):
+ self.ingestor.ensure_relationship_batch(
+ caller_spec,
+ cs.RelationshipType.CALLS,
+ (callee_type, cs.KEY_QUALIFIED_NAME, target_qn),
+ )
+ return True
+
+ def _parse_call_arguments(
+ self, call_node: Node
+ ) -> tuple[list[Node], dict[str, Node]]:
+ positional: list[Node] = []
+ keyword: dict[str, Node] = {}
+ args_node = call_node.child_by_field_name(cs.FIELD_ARGUMENTS)
+ if args_node is None:
+ return positional, keyword
+ for child in args_node.named_children:
+ if child.type == cs.TS_PY_KEYWORD_ARGUMENT:
+ name_node = child.child_by_field_name(cs.FIELD_NAME)
+ value_node = child.child_by_field_name(cs.FIELD_VALUE)
+ if (
+ name_node is not None
+ and value_node is not None
+ and (name := safe_decode_text(name_node)) is not None
+ ):
+ keyword[name] = value_node
+ else:
+ positional.append(child)
+ return positional, keyword
+
+ def _emit_callback_edge(
+ self,
+ source_spec: tuple[str, str, str],
+ arg_node: Node,
+ module_qn: str,
+ local_var_types: dict[str, str] | None,
+ class_context: str | None,
+ resolve_func,
+ ensure_rel,
+ ) -> None:
+ if not (arg_text := safe_decode_text(arg_node)):
+ return
+ if not (
+ resolved := resolve_func(
+ arg_text, module_qn, local_var_types, class_context
+ )
+ ):
+ return
+ res_type, res_qn = resolved
+ registry = self._resolver.function_registry
+ if res_type == cs.NodeLabel.CLASS:
+ init_qn = f"{res_qn}{cs.SEPARATOR_DOT}{cs.PY_METHOD_INIT}"
+ if init_qn not in registry:
+ return
+ res_type = cs.NodeLabel.METHOD
+ res_qn = init_qn
+ for target_qn in registry.variants(res_qn):
+ ensure_rel(
+ source_spec,
+ cs.RelationshipType.CALLS,
+ (res_type, cs.KEY_QUALIFIED_NAME, target_qn),
+ )
+
+ def _ingest_callable_param_calls(
+ self,
+ call_node: Node,
+ callee_type: str,
+ callee_qn: str,
+ module_qn: str,
+ local_var_types: dict[str, str] | None,
+ class_context: str | None,
+ resolve_func,
+ ensure_rel,
+ ) -> None:
+ if not (params := self._resolver.function_registry.callable_params(callee_qn)):
+ return
+ positional, keyword = self._parse_call_arguments(call_node)
+ source_spec = (callee_type, cs.KEY_QUALIFIED_NAME, callee_qn)
+ for param_name, index in params.items():
+ arg_node = keyword.get(param_name)
+ if arg_node is None and index < len(positional):
+ arg_node = positional[index]
+ if arg_node is not None:
+ self._emit_callback_edge(
+ source_spec,
+ arg_node,
+ module_qn,
+ local_var_types,
+ class_context,
+ resolve_func,
+ ensure_rel,
+ )
+
+ def _collect_callable_flow(
+ self,
+ call_node: Node,
+ callee_qn: str,
+ caller_qn: str,
+ caller_params: frozenset[str],
+ module_qn: str,
+ local_var_types: dict[str, str] | None,
+ class_context: str | None,
+ ) -> None:
+ # (H) Record, for each call-site argument that names a callable, whether it is a
+ # (H) concrete function or a parameter of the caller (a pass-through). The
+ # (H) fixpoint in finalize propagates concretes through pass-through params to
+ # (H) the functions that actually invoke them.
+ positional, keyword = self._parse_call_arguments(call_node)
+ items: list[tuple[int, str, Node]] = [
+ (index, "", node) for index, node in enumerate(positional)
+ ]
+ items.extend((-1, name, node) for name, node in keyword.items())
+ callable_labels = (
+ cs.NodeLabel.FUNCTION,
+ cs.NodeLabel.METHOD,
+ cs.NodeLabel.CLASS,
+ )
+ for position, keyword_name, arg_node in items:
+ if arg_node.type not in (cs.TS_PY_IDENTIFIER, cs.TS_PY_ATTRIBUTE):
+ continue
+ arg_text = safe_decode_text(arg_node)
+ if not arg_text:
+ continue
+ if arg_node.type == cs.TS_PY_IDENTIFIER and arg_text in caller_params:
+ self._flow_args.append(
+ _CallableFlowArg(
+ callee_qn, position, keyword_name, "", caller_qn, arg_text
+ )
+ )
+ continue
+ resolved = self._resolver.resolve_function_call(
+ arg_text, module_qn, local_var_types, class_context
+ )
+ if resolved is not None and resolved[0] in callable_labels:
+ self._flow_args.append(
+ _CallableFlowArg(
+ callee_qn, position, keyword_name, resolved[1], "", ""
+ )
+ )
+
+ def finalize_callable_param_flow(self) -> None:
+ # (H) Resolve the recorded call-site argument bindings to a fixpoint and emit a
+ # (H) CALLS edge from every function that invokes a callable parameter to each
+ # (H) concrete function that can reach it (directly or via pass-through params).
+ registry = self._resolver.function_registry
+ seeds: dict[tuple[str, str], set[str]] = defaultdict(set)
+ edges: dict[tuple[str, str], set[tuple[str, str]]] = defaultdict(set)
+ for arg in self._flow_args:
+ if arg.keyword:
+ param_name = arg.keyword
+ else:
+ callee_params = self._flow_param_names.get(arg.callee_qn)
+ if callee_params is None or not (
+ 0 <= arg.position < len(callee_params)
+ ):
+ continue
+ param_name = callee_params[arg.position]
+ slot = (arg.callee_qn, param_name)
+ if arg.source_concrete:
+ seeds[slot].add(arg.source_concrete)
else:
+ edges[slot].add((arg.source_caller, arg.source_param))
+
+ bindings: dict[tuple[str, str], set[str]] = {
+ k: set(v) for k, v in seeds.items()
+ }
+ for slot in edges:
+ bindings.setdefault(slot, set())
+ changed = True
+ while changed:
+ changed = False
+ for slot, sources in edges.items():
+ for source in sources:
+ if (reachable := bindings.get(source)) and not reachable.issubset(
+ bindings[slot]
+ ):
+ bindings[slot] |= reachable
+ changed = True
+
+ ensure_rel = self.ingestor.ensure_relationship_batch
+ for func_qn, invoked in (
+ (qn, registry.callable_params(qn)) for qn in self._flow_param_names
+ ):
+ if not invoked or (func_type := registry.get(func_qn)) is None:
continue
- logger.debug(
- ls.CALL_FOUND.format(
- caller=caller_qn,
- call_name=call_name,
- callee_type=callee_type,
- callee_qn=callee_qn,
+ source_spec = (func_type, cs.KEY_QUALIFIED_NAME, func_qn)
+ for param_name in invoked:
+ for target_qn in bindings.get((func_qn, param_name), ()):
+ target_type = registry.get(target_qn)
+ if target_type is None:
+ continue
+ for variant in registry.variants(target_qn):
+ ensure_rel(
+ source_spec,
+ cs.RelationshipType.CALLS,
+ (target_type, cs.KEY_QUALIFIED_NAME, variant),
+ )
+
+ def _ingest_callable_field_calls(
+ self,
+ call_name: str,
+ caller_spec: tuple[str, str, str],
+ local_var_types: dict[str, str] | None,
+ ensure_rel,
+ ) -> None:
+ recv, sep, field = call_name.rpartition(cs.SEPARATOR_DOT)
+ if not sep:
+ return
+ recv_type = local_var_types.get(recv) if local_var_types else None
+ targets = self._resolver.callable_field_targets(field, recv_type)
+ if not targets:
+ return
+ registry = self._resolver.function_registry
+ for target_qn in targets:
+ if target_qn in registry:
+ ensure_rel(
+ caller_spec,
+ cs.RelationshipType.CALLS,
+ (registry[target_qn], cs.KEY_QUALIFIED_NAME, target_qn),
)
+
+ def _ingest_higher_order_builtin_calls(
+ self,
+ call_node: Node,
+ caller_spec: tuple[str, str, str],
+ module_qn: str,
+ local_var_types: dict[str, str] | None,
+ class_context: str | None,
+ resolve_func,
+ ensure_rel,
+ ) -> None:
+ positional, keyword = self._parse_call_arguments(call_node)
+ for arg_node in (*positional, *keyword.values()):
+ self._emit_callback_edge(
+ caller_spec,
+ arg_node,
+ module_qn,
+ local_var_types,
+ class_context,
+ resolve_func,
+ ensure_rel,
)
- self.ingestor.ensure_relationship_batch(
- (caller_type, cs.KEY_QUALIFIED_NAME, caller_qn),
- cs.RelationshipType.CALLS,
- (callee_type, cs.KEY_QUALIFIED_NAME, callee_qn),
+ def _build_local_alias_map(
+ self, caller_node: Node, lang_config: LanguageSpec, module_qn: str
+ ) -> dict[str, str]:
+ identifier = cs.TS_PY_IDENTIFIER
+ attribute = cs.TS_PY_ATTRIBUTE
+ assignment = cs.TS_PY_ASSIGNMENT
+ left_field = cs.TS_FIELD_LEFT
+ right_field = cs.TS_FIELD_RIGHT
+ function_types = lang_config.function_node_types
+ class_types = lang_config.class_node_types
+ aliases: dict[str, str] = {}
+ stack = list(caller_node.children)
+ while stack:
+ node = stack.pop()
+ node_type = node.type
+ if node_type in function_types or node_type in class_types:
+ continue
+ if node_type == assignment:
+ left = node.child_by_field_name(left_field)
+ right = node.child_by_field_name(right_field)
+ if (
+ left is not None
+ and left.type == identifier
+ and (left_text := left.text) is not None
+ and right is not None
+ and (
+ target := self._alias_reference_text(
+ right, identifier, attribute, module_qn
+ )
+ )
+ is not None
+ ):
+ aliases.setdefault(left_text.decode(cs.ENCODING_UTF8), target)
+ stack.extend(node.children)
+ return aliases
+
+ def _alias_reference_text(
+ self, right: Node, identifier: str, attribute: str, module_qn: str
+ ) -> str | None:
+ # (H) An alias rhs is a plain name/attribute, a conditional that picks one
+ # (H) (resolve_builtin_call if is_js_ts else None), or getattr(recv, name)
+ # (H) dynamic dispatch. Take the name/attribute branch (consequence or
+ # (H) alternative, never the condition) or build recv. for getattr.
+ if right.type in (identifier, attribute):
+ return right.text.decode(cs.ENCODING_UTF8) if right.text else None
+ if right.type == cs.TS_PY_CONDITIONAL_EXPRESSION and right.named_children:
+ for branch in (right.named_children[0], right.named_children[-1]):
+ if branch.type in (identifier, attribute) and branch.text:
+ return branch.text.decode(cs.ENCODING_UTF8)
+ if right.type == cs.TS_PY_CALL:
+ return self._getattr_reference_text(right, identifier, attribute, module_qn)
+ return None
+
+ def _getattr_reference_text(
+ self, call: Node, identifier: str, attribute: str, module_qn: str
+ ) -> str | None:
+ func = call.child_by_field_name(cs.TS_FIELD_FUNCTION)
+ args = call.child_by_field_name(cs.FIELD_ARGUMENTS)
+ if (
+ func is None
+ or safe_decode_text(func) != cs.PY_BUILTIN_GETATTR
+ or args is None
+ or len(args.named_children) < 2
+ ):
+ return None
+ receiver, name_node = args.named_children[0], args.named_children[1]
+ if receiver.type not in (identifier, attribute):
+ return None
+ if (name := self._resolve_str_const(name_node, module_qn)) is None:
+ return None
+ return f"{safe_decode_text(receiver)}{cs.SEPARATOR_DOT}{name}"
+
+ def _resolve_str_const(self, node: Node, module_qn: str) -> str | None:
+ # (H) Resolve a getattr name argument to its string value: a string literal
+ # (H) directly, or a module-level constant (cs.METHOD_X / METHOD_X) read from
+ # (H) the defining module's AST.
+ if node.type == cs.TS_PY_STRING:
+ content = next(
+ (c for c in node.children if c.type == cs.TS_PY_STRING_CONTENT), None
+ )
+ return safe_decode_text(content) if content is not None else None
+ if node.type not in (cs.TS_PY_IDENTIFIER, cs.TS_PY_ATTRIBUTE):
+ return None
+ name_text = safe_decode_text(node)
+ if not name_text:
+ return None
+ import_map = self._resolver.import_processor.import_mapping.get(module_qn, {})
+ prefix, _, const_name = name_text.rpartition(cs.SEPARATOR_DOT)
+ if not prefix:
+ mapped = import_map.get(const_name)
+ const_module_qn = (
+ mapped.rsplit(cs.SEPARATOR_DOT, 1)[0] if mapped else module_qn
)
+ elif (mapped_module := import_map.get(prefix)) is not None:
+ const_module_qn = mapped_module
+ else:
+ const_module_qn = prefix
+ return self._module_string_constant(const_module_qn, const_name)
+
+ def _module_string_constant(self, module_qn: str, const_name: str) -> str | None:
+ type_inference = self._resolver.type_inference
+ file_path = type_inference.module_qn_to_file_path.get(module_qn)
+ if file_path is None or file_path not in type_inference.ast_cache:
+ return None
+ root_node, _ = type_inference.ast_cache[file_path]
+ for child in root_node.children:
+ if child.type != cs.TS_PY_EXPRESSION_STATEMENT or not child.children:
+ continue
+ assignment = child.children[0]
+ if assignment.type != cs.TS_PY_ASSIGNMENT:
+ continue
+ left = assignment.child_by_field_name(cs.TS_FIELD_LEFT)
+ right = assignment.child_by_field_name(cs.TS_FIELD_RIGHT)
+ if (
+ left is not None
+ and left.type == cs.TS_PY_IDENTIFIER
+ and safe_decode_text(left) == const_name
+ and right is not None
+ and right.type == cs.TS_PY_STRING
+ ):
+ return self._resolve_str_const(right, module_qn)
+ return None
+
+ def _ingest_property_accesses(
+ self,
+ caller_node: Node,
+ caller_spec: tuple[str, str, str],
+ caller_qn: str,
+ module_qn: str,
+ local_var_types: dict[str, str] | None,
+ class_context: str | None,
+ lang_config: LanguageSpec,
+ prop_names: set[str],
+ ) -> None:
+ # (H) Accessing an @property getter invokes the getter method at runtime, but
+ # (H) tree-sitter sees a plain attribute, not a call. Resolve attribute
+ # (H) accesses whose tail names a known property and emit a CALLS edge to the
+ # (H) getter (skipping the attribute that is itself a call's function, which
+ # (H) the call path above already resolves).
+ resolver = self._resolver
+ resolve_func = resolver.resolve_function_call
+ registry = resolver.function_registry
+ ensure_rel = self.ingestor.ensure_relationship_batch
+ calls_rel = cs.RelationshipType.CALLS
+ qn_key = cs.KEY_QUALIFIED_NAME
+ method_label = cs.NodeLabel.METHOD
+ attr_type = cs.TS_PY_ATTRIBUTE
+ call_type = cs.TS_PY_CALL
+ func_field = cs.TS_FIELD_FUNCTION
+ function_types = lang_config.function_node_types
+ class_types = lang_config.class_node_types
+ seen: set[str] = set()
+
+ stack = list(caller_node.children)
+ while stack:
+ node = stack.pop()
+ node_type = node.type
+ if node_type in function_types or node_type in class_types:
+ continue
+ if node_type == attr_type and (text := node.text) is not None:
+ attr_text = text.decode(cs.ENCODING_UTF8)
+ if attr_text.rsplit(cs.SEPARATOR_DOT, 1)[-1] in prop_names:
+ parent = node.parent
+ is_call_target = (
+ parent is not None
+ and parent.type == call_type
+ and parent.child_by_field_name(func_field) is node
+ )
+ if not is_call_target and (
+ callee_info := resolve_func(
+ attr_text, module_qn, local_var_types, class_context
+ )
+ ):
+ callee_qn = callee_info[1]
+ if (
+ registry.is_property(callee_qn)
+ and callee_qn != caller_qn
+ and callee_qn not in seen
+ ):
+ seen.add(callee_qn)
+ for target_qn in registry.variants(callee_qn):
+ ensure_rel(
+ caller_spec,
+ calls_rel,
+ (method_label, qn_key, target_qn),
+ )
+ stack.extend(node.children)
def _build_nested_qualified_name(
self,
@@ -337,9 +1463,7 @@ def _build_nested_qualified_name(
if not isinstance(current, Node):
logger.warning(
- ls.CALL_UNEXPECTED_PARENT.format(
- node=func_node, parent_type=type(current)
- )
+ ls.CALL_UNEXPECTED_PARENT, node=func_node, parent_type=type(current)
)
return None
diff --git a/codebase_rag/parsers/call_resolver.py b/codebase_rag/parsers/call_resolver.py
index 322a583a3..3815ff344 100644
--- a/codebase_rag/parsers/call_resolver.py
+++ b/codebase_rag/parsers/call_resolver.py
@@ -1,6 +1,7 @@
from __future__ import annotations
import re
+from collections import defaultdict, deque
from loguru import logger
from tree_sitter import Node
@@ -12,8 +13,28 @@
from .py import resolve_class_name
from .type_inference import TypeInferenceEngine
+_SEPARATOR_PATTERN = re.compile(r"[.:]|::")
+_SEARCH_NAME_CACHE: dict[str, str] = {}
+_CHAINED_METHOD_PATTERN = re.compile(r"\.([^.()]+)$")
+_QN_SPLIT_CACHE: dict[str, tuple[list[str], int]] = {}
+
class CallResolver:
+ __slots__ = (
+ "function_registry",
+ "import_processor",
+ "type_inference",
+ "class_inheritance",
+ "_simple_resolution_cache",
+ "_wildcard_cache",
+ "_protocol_impl_cache",
+ "_field_bindings",
+ "_field_to_classes",
+ "_subclass_map_cache",
+ "_protocol_classes_cache",
+ "_struct_impl_cache",
+ )
+
def __init__(
self,
function_registry: FunctionRegistryTrieProtocol,
@@ -25,16 +46,95 @@ def __init__(
self.import_processor = import_processor
self.type_inference = type_inference
self.class_inheritance = class_inheritance
+ self._simple_resolution_cache: dict[
+ tuple[str, str], tuple[str, str] | None
+ ] = {}
+ self._wildcard_cache: dict[int, list[tuple[str, str]]] = {}
+ self._protocol_impl_cache: dict[str, str] | None = None
+ self._field_bindings: dict[tuple[str, str], set[str]] = {}
+ self._field_to_classes: dict[str, set[str]] = {}
+ self._subclass_map_cache: dict[str, set[str]] | None = None
+ self._protocol_classes_cache: set[str] | None = None
+ self._struct_impl_cache: dict[str, set[str]] = {}
+
+ def record_callable_field_binding(
+ self, class_qn: str, field: str, func_qn: str
+ ) -> None:
+ # (H) A NamedTuple/dataclass field holding a function reference: every
+ # (H) function bound to it at any construction site is a possible callee
+ # (H) when the field is invoked. Recording all of them is a sound call
+ # (H) graph (each runs for its own configuration), so recall is complete.
+ self._field_bindings.setdefault((class_qn, field), set()).add(func_qn)
+ self._field_to_classes.setdefault(field, set()).add(class_qn)
+
+ def callable_field_targets(
+ self, field: str, recv_type: str | None = None
+ ) -> set[str]:
+ classes = self._field_to_classes.get(field)
+ if not classes:
+ return set()
+ if recv_type:
+ simple = recv_type.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+ matched = [
+ qn
+ for qn in classes
+ if qn == recv_type or qn.rsplit(cs.SEPARATOR_DOT, 1)[-1] == simple
+ ]
+ if len(matched) == 1:
+ return self._field_bindings.get((matched[0], field), set())
+ # (H) Receiver type unknown or ambiguous: only resolve when exactly one
+ # (H) class declares this callable field, so the targets are unambiguous.
+ if len(classes) == 1:
+ return self._field_bindings.get((next(iter(classes)), field), set())
+ return set()
def _resolve_class_qn_from_type(
self, var_type: str, import_map: dict[str, str], module_qn: str
) -> str:
+ var_type = self._strip_optional(var_type)
if cs.SEPARATOR_DOT in var_type:
- return var_type
+ return self._follow_reexports(var_type)
if var_type in import_map:
- return import_map[var_type]
+ return self._follow_reexports(import_map[var_type])
return self._resolve_class_name(var_type, module_qn) or ""
+ def _strip_optional(self, var_type: str) -> str:
+ # (H) An Optional annotation (X | None) names a single concrete class; reduce it
+ # (H) so attribute/operator resolution can find that class. Genuine multi-type
+ # (H) unions stay unresolved (ambiguous).
+ if cs.PY_UNION_SEPARATOR not in var_type:
+ return var_type
+ non_none = [
+ member
+ for part in var_type.split(cs.PY_UNION_SEPARATOR)
+ if (member := part.strip()) and member != cs.PY_NONE
+ ]
+ return non_none[0] if len(non_none) == 1 else var_type
+
+ def _follow_reexports(self, class_qn: str) -> str:
+ # (H) `from .pkg import Cls` records the importer's name against the re-export
+ # (H) module (pkg.Cls), not the class's real definition (pkg.mod.Cls), so a
+ # (H) class_qn that is not itself registered may be a re-export. Follow the
+ # (H) module's own import map one hop at a time until a registered class is
+ # (H) reached, guarding against cycles.
+ seen: set[str] = set()
+ current = class_qn
+ while (
+ current
+ and current not in seen
+ and current not in self.function_registry
+ and cs.SEPARATOR_DOT in current
+ ):
+ seen.add(current)
+ module_qn, _, name = current.rpartition(cs.SEPARATOR_DOT)
+ following = self.import_processor.import_mapping.get(module_qn, {}).get(
+ name
+ )
+ if not following or following == current:
+ break
+ current = following
+ return current
+
def _try_resolve_method(
self, class_qn: str, method_name: str, separator: str = cs.SEPARATOR_DOT
) -> tuple[str, str] | None:
@@ -50,6 +150,95 @@ def resolve_function_call(
local_var_types: dict[str, str] | None = None,
class_context: str | None = None,
) -> tuple[str, str] | None:
+ return self._redirect_protocol_method(
+ self._resolve_function_call(
+ call_name, module_qn, local_var_types, class_context
+ )
+ )
+
+ def _protocol_impl_map(self) -> dict[str, str]:
+ # (H) A Protocol stub never runs; the concrete implementer does. Map each
+ # (H) XxxProtocol to a unique non-Protocol class named Xxx (the suffix
+ # (H) convention disambiguates the real impl from test mocks or other
+ # (H) structural conformers, which structural matching alone cannot).
+ if self._protocol_impl_cache is not None:
+ return self._protocol_impl_cache
+ sep = cs.SEPARATOR_DOT
+ protocols: set[str] = set()
+ classes_by_simple: dict[str, list[str]] = defaultdict(list)
+ for qn, bases in self.class_inheritance.items():
+ classes_by_simple[qn.rsplit(sep, 1)[-1]].append(qn)
+ if any(base.rsplit(sep, 1)[-1] == cs.PY_PROTOCOL for base in bases):
+ protocols.add(qn)
+ impl: dict[str, str] = {}
+ for protocol_qn in protocols:
+ simple = protocol_qn.rsplit(sep, 1)[-1]
+ if simple == cs.PY_PROTOCOL or not simple.endswith(cs.PY_PROTOCOL):
+ continue
+ base_name = simple[: -len(cs.PY_PROTOCOL)]
+ candidates = [
+ qn for qn in classes_by_simple.get(base_name, []) if qn not in protocols
+ ]
+ if len(candidates) == 1:
+ impl[protocol_qn] = candidates[0]
+ self._protocol_impl_cache = impl
+ return impl
+
+ def _protocol_classes(self) -> set[str]:
+ if self._protocol_classes_cache is None:
+ sep = cs.SEPARATOR_DOT
+ self._protocol_classes_cache = {
+ qn
+ for qn, bases in self.class_inheritance.items()
+ if any(base.rsplit(sep, 1)[-1] == cs.PY_PROTOCOL for base in bases)
+ }
+ return self._protocol_classes_cache
+
+ def protocol_dispatch_targets(self, callee_qn: str) -> set[tuple[str, str]]:
+ # (H) A call resolved to a Protocol stub method (P.M) never runs the stub: the
+ # (H) runtime receiver is some conformer, so the sound call graph emits an edge
+ # (H) to M on every non-Protocol class that defines it. Gating on the resolved
+ # (H) target being a Protocol method keeps this from firing on ordinary calls.
+ class_qn, sep, method_name = callee_qn.rpartition(cs.SEPARATOR_DOT)
+ if not sep or class_qn not in self._protocol_classes():
+ return set()
+ protocols = self._protocol_classes()
+ targets: set[tuple[str, str]] = set()
+ for qn in self.function_registry.find_ending_with(method_name):
+ definer, dot, name = qn.rpartition(cs.SEPARATOR_DOT)
+ if dot and name == method_name and definer not in protocols:
+ targets.add((self.function_registry[qn], qn))
+ return targets
+
+ def _redirect_protocol_method(
+ self, result: tuple[str, str] | None
+ ) -> tuple[str, str] | None:
+ if result is None:
+ return result
+ class_qn, sep, method_name = result[1].rpartition(cs.SEPARATOR_DOT)
+ if not sep:
+ return result
+ impl_qn = self._protocol_impl_map().get(class_qn)
+ if impl_qn is None:
+ return result
+ redirected = f"{impl_qn}{cs.SEPARATOR_DOT}{method_name}"
+ if redirected in self.function_registry:
+ return self.function_registry[redirected], redirected
+ return result
+
+ def _resolve_function_call(
+ self,
+ call_name: str,
+ module_qn: str,
+ local_var_types: dict[str, str] | None = None,
+ class_context: str | None = None,
+ ) -> tuple[str, str] | None:
+ use_cache = not local_var_types
+ if use_cache:
+ cache_key = (call_name, module_qn)
+ if cache_key in self._simple_resolution_cache:
+ return self._simple_resolution_cache[cache_key]
+
if result := self._try_resolve_iife(call_name, module_qn):
return result
@@ -62,12 +251,24 @@ def resolve_function_call(
if result := self._try_resolve_via_imports(
call_name, module_qn, local_var_types
):
+ if use_cache:
+ self._simple_resolution_cache[cache_key] = result
return result
if result := self._try_resolve_same_module(call_name, module_qn):
+ if use_cache:
+ self._simple_resolution_cache[cache_key] = result
return result
- return self._try_resolve_via_trie(call_name, module_qn)
+ if class_context and (
+ result := self._resolve_self_sibling_method(call_name, class_context)
+ ):
+ return result
+
+ result = self._try_resolve_via_trie(call_name, module_qn)
+ if use_cache:
+ self._simple_resolution_cache[cache_key] = result
+ return result
def _try_resolve_iife(
self, call_name: str, module_qn: str
@@ -119,9 +320,7 @@ def _try_resolve_direct_import(
return None
imported_qn = import_map[call_name]
if imported_qn in self.function_registry:
- logger.debug(
- ls.CALL_DIRECT_IMPORT.format(call_name=call_name, qn=imported_qn)
- )
+ logger.debug(ls.CALL_DIRECT_IMPORT, call_name=call_name, qn=imported_qn)
return self.function_registry[imported_qn], imported_qn
return None
@@ -132,10 +331,15 @@ def _try_resolve_qualified_call(
module_qn: str,
local_var_types: dict[str, str] | None,
) -> tuple[str, str] | None:
- if not self._has_separator(call_name):
+ if cs.SEPARATOR_DOUBLE_COLON in call_name:
+ separator = cs.SEPARATOR_DOUBLE_COLON
+ elif cs.SEPARATOR_COLON in call_name:
+ separator = cs.SEPARATOR_COLON
+ elif cs.SEPARATOR_DOT in call_name:
+ separator = cs.SEPARATOR_DOT
+ else:
return None
- separator = self._get_separator(call_name)
parts = call_name.split(separator)
if len(parts) == 2:
@@ -170,9 +374,17 @@ def _get_separator(self, call_name: str) -> str:
def _try_resolve_wildcard_imports(
self, call_name: str, import_map: dict[str, str]
) -> tuple[str, str] | None:
- for local_name, imported_qn in import_map.items():
- if not local_name.startswith("*"):
- continue
+ map_id = id(import_map)
+ if map_id not in self._wildcard_cache:
+ self._wildcard_cache[map_id] = (
+ [(k, v) for k, v in import_map.items() if k[0] == "*"]
+ if import_map
+ else []
+ )
+ wildcards = self._wildcard_cache[map_id]
+ if not wildcards:
+ return None
+ for _, imported_qn in wildcards:
if result := self._try_wildcard_qns(call_name, imported_qn):
return result
return None
@@ -187,9 +399,7 @@ def _try_wildcard_qns(
for wildcard_qn in potential_qns:
if wildcard_qn in self.function_registry:
- logger.debug(
- ls.CALL_WILDCARD.format(call_name=call_name, qn=wildcard_qn)
- )
+ logger.debug(ls.CALL_WILDCARD, call_name=call_name, qn=wildcard_qn)
return self.function_registry[wildcard_qn], wildcard_qn
return None
@@ -199,7 +409,7 @@ def _try_resolve_same_module(
same_module_func_qn = f"{module_qn}.{call_name}"
if same_module_func_qn in self.function_registry:
logger.debug(
- ls.CALL_SAME_MODULE.format(call_name=call_name, qn=same_module_func_qn)
+ ls.CALL_SAME_MODULE, call_name=call_name, qn=same_module_func_qn
)
return self.function_registry[same_module_func_qn], same_module_func_qn
return None
@@ -207,19 +417,39 @@ def _try_resolve_same_module(
def _try_resolve_via_trie(
self, call_name: str, module_qn: str
) -> tuple[str, str] | None:
- search_name = re.split(r"[.:]|::", call_name)[-1]
+ search_name = _SEARCH_NAME_CACHE.get(call_name)
+ if search_name is None:
+ search_name = _SEPARATOR_PATTERN.split(call_name)[-1]
+ _SEARCH_NAME_CACHE[call_name] = search_name
possible_matches = self.function_registry.find_ending_with(search_name)
if not possible_matches:
- logger.debug(ls.CALL_UNRESOLVED.format(call_name=call_name))
+ logger.debug(ls.CALL_UNRESOLVED, call_name=call_name)
return None
- possible_matches.sort(
- key=lambda qn: self._calculate_import_distance(qn, module_qn)
- )
- best_candidate_qn = possible_matches[0]
- logger.debug(
- ls.CALL_TRIE_FALLBACK.format(call_name=call_name, qn=best_candidate_qn)
- )
+ if len(possible_matches) == 1:
+ best_candidate_qn = possible_matches[0]
+ else:
+ caller_parts = module_qn.split(cs.SEPARATOR_DOT)
+ caller_len = len(caller_parts)
+ caller_parent_prefix = (
+ cs.SEPARATOR_DOT.join(caller_parts[:-1]) + cs.SEPARATOR_DOT
+ if caller_len > 1
+ else ""
+ )
+ best_candidate_qn = min(
+ possible_matches,
+ key=lambda qn: (
+ # (H) An @abstractmethod stub never runs when a concrete override
+ # (H) exists, so prefer concrete candidates over abstract ones
+ # (H) even when the abstract stub is closer by import distance.
+ self.function_registry.is_abstract(qn),
+ self._import_distance_fast(
+ qn, caller_parts, caller_len, caller_parent_prefix
+ ),
+ qn,
+ ),
+ )
+ logger.debug(ls.CALL_TRIE_FALLBACK, call_name=call_name, qn=best_candidate_qn)
return self.function_registry[best_candidate_qn], best_candidate_qn
def _resolve_two_part_call(
@@ -293,23 +523,21 @@ def _try_method_on_class(
method_qn = f"{class_qn}{separator}{method_name}"
if method_qn in self.function_registry:
logger.debug(
- ls.CALL_TYPE_INFERRED.format(
- call_name=call_name,
- method_qn=method_qn,
- obj=object_name,
- var_type=var_type,
- )
+ ls.CALL_TYPE_INFERRED,
+ call_name=call_name,
+ method_qn=method_qn,
+ obj=object_name,
+ var_type=var_type,
)
return self.function_registry[method_qn], method_qn
if inherited := self._resolve_inherited_method(class_qn, method_name):
logger.debug(
- ls.CALL_TYPE_INFERRED_INHERITED.format(
- call_name=call_name,
- method_qn=inherited[1],
- obj=object_name,
- var_type=var_type,
- )
+ ls.CALL_TYPE_INFERRED_INHERITED,
+ call_name=call_name,
+ method_qn=inherited[1],
+ obj=object_name,
+ var_type=var_type,
)
return inherited
return None
@@ -336,7 +564,7 @@ def _try_resolve_via_import(
if method_qn in self.function_registry:
logger.debug(
- ls.CALL_IMPORT_STATIC.format(call_name=call_name, method_qn=method_qn)
+ ls.CALL_IMPORT_STATIC, call_name=call_name, method_qn=method_qn
)
return self.function_registry[method_qn], method_qn
return None
@@ -377,7 +605,7 @@ def _try_resolve_module_method(
method_qn = f"{module_qn}.{method_name}"
if method_qn in self.function_registry:
logger.debug(
- ls.CALL_OBJECT_METHOD.format(call_name=call_name, method_qn=method_qn)
+ ls.CALL_OBJECT_METHOD, call_name=call_name, method_qn=method_qn
)
return self.function_registry[method_qn], method_qn
return None
@@ -401,12 +629,11 @@ def _resolve_self_attribute_call(
method_qn = f"{class_qn}.{method_name}"
if method_qn in self.function_registry:
logger.debug(
- ls.CALL_INSTANCE_ATTR.format(
- call_name=call_name,
- method_qn=method_qn,
- attr_ref=attribute_ref,
- var_type=var_type,
- )
+ ls.CALL_INSTANCE_ATTR,
+ call_name=call_name,
+ method_qn=method_qn,
+ attr_ref=attribute_ref,
+ var_type=var_type,
)
return self.function_registry[method_qn], method_qn
@@ -414,12 +641,11 @@ def _resolve_self_attribute_call(
class_qn, method_name
):
logger.debug(
- ls.CALL_INSTANCE_ATTR_INHERITED.format(
- call_name=call_name,
- method_qn=inherited_method[1],
- attr_ref=attribute_ref,
- var_type=var_type,
- )
+ ls.CALL_INSTANCE_ATTR_INHERITED,
+ call_name=call_name,
+ method_qn=inherited_method[1],
+ attr_ref=attribute_ref,
+ var_type=var_type,
)
return inherited_method
@@ -441,9 +667,9 @@ def _resolve_multi_part_call(
method_qn = f"{class_qn}.{method_name}"
if method_qn in self.function_registry:
logger.debug(
- ls.CALL_IMPORT_QUALIFIED.format(
- call_name=call_name, method_qn=method_qn
- )
+ ls.CALL_IMPORT_QUALIFIED,
+ call_name=call_name,
+ method_qn=method_qn,
)
return self.function_registry[method_qn], method_qn
@@ -455,12 +681,11 @@ def _resolve_multi_part_call(
method_qn = f"{class_qn}.{method_name}"
if method_qn in self.function_registry:
logger.debug(
- ls.CALL_INSTANCE_QUALIFIED.format(
- call_name=call_name,
- method_qn=method_qn,
- class_name=class_name,
- var_type=var_type,
- )
+ ls.CALL_INSTANCE_QUALIFIED,
+ call_name=call_name,
+ method_qn=method_qn,
+ class_name=class_name,
+ var_type=var_type,
)
return self.function_registry[method_qn], method_qn
@@ -468,17 +693,75 @@ def _resolve_multi_part_call(
class_qn, method_name
):
logger.debug(
- ls.CALL_INSTANCE_INHERITED.format(
- call_name=call_name,
- method_qn=inherited_method[1],
- class_name=class_name,
- var_type=var_type,
- )
+ ls.CALL_INSTANCE_INHERITED,
+ call_name=call_name,
+ method_qn=inherited_method[1],
+ class_name=class_name,
+ var_type=var_type,
)
return inherited_method
return None
+ def operator_dunder_targets(
+ self,
+ operand_text: str,
+ dunder: str,
+ module_qn: str,
+ local_var_types: dict[str, str] | None,
+ ) -> set[tuple[str, str]]:
+ # (H) Operator syntax dispatches to a dunder on the operand's type. Resolve only
+ # (H) when the operand type is known; never via the name-only trie fallback, so a
+ # (H) builtin container does not borrow a first-party dunder. A Protocol-typed
+ # (H) operand dispatches to the dunder on each structural implementer (which may
+ # (H) define the dunder even when the Protocol stub does not, e.g. __len__).
+ if not local_var_types or not (var_type := local_var_types.get(operand_text)):
+ return set()
+ import_map = self.import_processor.import_mapping.get(module_qn, {})
+ class_qn = self._resolve_class_qn_from_type(var_type, import_map, module_qn)
+ if not class_qn:
+ return set()
+ if class_qn in self._protocol_classes():
+ # (H) Naming convention (XxxProtocol -> Xxx) is robust when it applies;
+ # (H) structural conformance covers protocols whose implementer is named
+ # (H) differently. Union both so neither gap drops a concrete target.
+ classes = set(self._protocol_structural_implementers(class_qn))
+ if named_impl := self._protocol_impl_map().get(class_qn):
+ classes.add(named_impl)
+ else:
+ classes = {class_qn}
+ targets: set[tuple[str, str]] = set()
+ for candidate in classes:
+ if resolved := self._try_resolve_method(candidate, dunder):
+ targets.add(resolved)
+ return targets
+
+ def _protocol_structural_implementers(self, protocol_qn: str) -> set[str]:
+ # (H) Classes that define every method declared on the Protocol (own or
+ # (H) inherited). Used to dispatch operator dunders to the concrete type when the
+ # (H) Protocol/implementer names don't follow the XxxProtocol convention.
+ if protocol_qn in self._struct_impl_cache:
+ return self._struct_impl_cache[protocol_qn]
+ sep = cs.SEPARATOR_DOT
+ protocol_methods = {
+ qn.rsplit(sep, 1)[-1]
+ for qn, node_type in self.function_registry.find_with_prefix(protocol_qn)
+ if node_type == NodeType.METHOD and qn.rsplit(sep, 1)[0] == protocol_qn
+ }
+ result: set[str] = set()
+ if protocol_methods:
+ protocols = self._protocol_classes()
+ for candidate in self.class_inheritance:
+ if candidate in protocols:
+ continue
+ if all(
+ self._try_resolve_method(candidate, method)
+ for method in protocol_methods
+ ):
+ result.add(candidate)
+ self._struct_impl_cache[protocol_qn] = result
+ return result
+
def resolve_builtin_call(self, call_name: str) -> tuple[str, str] | None:
if call_name in cs.JS_BUILTIN_PATTERNS:
return (cs.NodeLabel.FUNCTION, f"{cs.BUILTIN_PREFIX}.{call_name}")
@@ -536,7 +819,7 @@ def _resolve_chained_call(
module_qn: str,
local_var_types: dict[str, str] | None = None,
) -> tuple[str, str] | None:
- match = re.search(r"\.([^.()]+)$", call_name)
+ match = _CHAINED_METHOD_PATTERN.search(call_name)
if not match:
return None
@@ -559,12 +842,11 @@ def _resolve_chained_call(
if method_qn in self.function_registry:
logger.debug(
- ls.CALL_CHAINED.format(
- call_name=call_name,
- method_qn=method_qn,
- obj_expr=object_expr,
- obj_type=object_type,
- )
+ ls.CALL_CHAINED,
+ call_name=call_name,
+ method_qn=method_qn,
+ obj_expr=object_expr,
+ obj_type=object_type,
)
return self.function_registry[method_qn], method_qn
@@ -572,12 +854,11 @@ def _resolve_chained_call(
full_object_type, final_method
):
logger.debug(
- ls.CALL_CHAINED_INHERITED.format(
- call_name=call_name,
- method_qn=inherited_method[1],
- obj_expr=object_expr,
- obj_type=object_type,
- )
+ ls.CALL_CHAINED_INHERITED,
+ call_name=call_name,
+ method_qn=inherited_method[1],
+ obj_expr=object_expr,
+ obj_type=object_type,
)
return inherited_method
@@ -596,45 +877,118 @@ def _resolve_super_call(
current_class_qn = class_context
if not current_class_qn:
- logger.debug(ls.CALL_SUPER_NO_CONTEXT.format(call_name=call_name))
+ logger.debug(ls.CALL_SUPER_NO_CONTEXT, call_name=call_name)
return None
if current_class_qn not in self.class_inheritance:
- logger.debug(ls.CALL_SUPER_NO_INHERITANCE.format(class_qn=current_class_qn))
+ logger.debug(ls.CALL_SUPER_NO_INHERITANCE, class_qn=current_class_qn)
return None
parent_classes = self.class_inheritance[current_class_qn]
if not parent_classes:
- logger.debug(ls.CALL_SUPER_NO_PARENTS.format(class_qn=current_class_qn))
+ logger.debug(ls.CALL_SUPER_NO_PARENTS, class_qn=current_class_qn)
return None
if result := self._resolve_inherited_method(current_class_qn, method_name):
callee_type, parent_method_qn = result
logger.debug(
- ls.CALL_SUPER_RESOLVED.format(
- call_name=call_name, method_qn=parent_method_qn
- )
+ ls.CALL_SUPER_RESOLVED,
+ call_name=call_name,
+ method_qn=parent_method_qn,
)
return callee_type, parent_method_qn
logger.debug(
- ls.CALL_SUPER_UNRESOLVED.format(
- call_name=call_name, class_qn=current_class_qn
- )
+ ls.CALL_SUPER_UNRESOLVED,
+ call_name=call_name,
+ class_qn=current_class_qn,
)
return None
+ def _resolve_self_sibling_method(
+ self, call_name: str, class_context: str
+ ) -> tuple[str, str] | None:
+ # (H) self.method() in a mixin may call a method defined on a SIBLING mixin
+ # (H) (neither is the other's base); both are combined into a concrete class.
+ # (H) Resolve through the concrete subclasses' MRO and accept the target only
+ # (H) when it is unambiguous, so an unrelated same-named method cannot win.
+ parts = call_name.split(cs.SEPARATOR_DOT)
+ if len(parts) != 2 or parts[0] != cs.KEYWORD_SELF:
+ return None
+ method_name = parts[1]
+ candidates: set[str] = set()
+ for subclass_qn in self._concrete_subclasses(class_context):
+ candidates |= self._mro_method_qns(subclass_qn, method_name)
+ if not candidates:
+ return None
+ # (H) An @abstractmethod stub never runs when a concrete sibling implements the
+ # (H) method, so prefer concrete candidates; resolve only when unambiguous.
+ chosen = {
+ qn for qn in candidates if not self.function_registry.is_abstract(qn)
+ } or candidates
+ if len(chosen) != 1:
+ return None
+ method_qn = next(iter(chosen))
+ logger.debug(
+ ls.CALL_INSTANCE_ATTR_INHERITED,
+ call_name=call_name,
+ method_qn=method_qn,
+ attr_ref=cs.KEYWORD_SELF,
+ var_type=class_context,
+ )
+ return self.function_registry[method_qn], method_qn
+
+ def _mro_method_qns(self, class_qn: str, method_name: str) -> set[str]:
+ results: set[str] = set()
+ visited: set[str] = set()
+ queue: deque[str] = deque([class_qn])
+ while queue:
+ current = self._follow_reexports(queue.popleft())
+ if current in visited:
+ continue
+ visited.add(current)
+ method_qn = f"{current}.{method_name}"
+ if method_qn in self.function_registry:
+ results.add(method_qn)
+ queue.extend(self.class_inheritance.get(current, ()))
+ return results
+
+ def _subclass_map(self) -> dict[str, set[str]]:
+ if self._subclass_map_cache is None:
+ mapping: dict[str, set[str]] = defaultdict(set)
+ for subclass_qn, bases in self.class_inheritance.items():
+ for base in bases:
+ mapping[self._follow_reexports(base)].add(subclass_qn)
+ self._subclass_map_cache = mapping
+ return self._subclass_map_cache
+
+ def _concrete_subclasses(self, class_qn: str) -> set[str]:
+ subclass_map = self._subclass_map()
+ found: set[str] = set()
+ stack = list(subclass_map.get(class_qn, ()))
+ while stack:
+ current = stack.pop()
+ if current in found:
+ continue
+ found.add(current)
+ stack.extend(subclass_map.get(current, ()))
+ return found
+
def _resolve_inherited_method(
self, class_qn: str, method_name: str
) -> tuple[str, str] | None:
if class_qn not in self.class_inheritance:
return None
- queue = list(self.class_inheritance.get(class_qn, []))
- visited = set(queue)
+ bfs_queue = deque(self.class_inheritance.get(class_qn, []))
+ visited = set(bfs_queue)
- while queue:
- parent_class_qn = queue.pop(0)
+ while bfs_queue:
+ # (H) Base classes are recorded by the name the subclass imported, which
+ # (H) may be a package re-export (class_ingest.ClassIngestMixin) rather than
+ # (H) the real definition (class_ingest.mixin.ClassIngestMixin); follow the
+ # (H) re-export so the inherited method qn matches the registry.
+ parent_class_qn = self._follow_reexports(bfs_queue.popleft())
parent_method_qn = f"{parent_class_qn}.{method_name}"
if parent_method_qn in self.function_registry:
@@ -647,7 +1001,7 @@ def _resolve_inherited_method(
for grandparent_qn in self.class_inheritance[parent_class_qn]:
if grandparent_qn not in visited:
visited.add(grandparent_qn)
- queue.append(grandparent_qn)
+ bfs_queue.append(grandparent_qn)
return None
@@ -673,6 +1027,30 @@ def _calculate_import_distance(
return base_distance
+ def _import_distance_fast(
+ self,
+ candidate_qn: str,
+ caller_parts: list[str],
+ caller_len: int,
+ caller_parent_prefix: str,
+ ) -> int:
+ if candidate_qn in _QN_SPLIT_CACHE:
+ candidate_parts, candidate_len = _QN_SPLIT_CACHE[candidate_qn]
+ else:
+ candidate_parts = candidate_qn.split(cs.SEPARATOR_DOT)
+ candidate_len = len(candidate_parts)
+ _QN_SPLIT_CACHE[candidate_qn] = (candidate_parts, candidate_len)
+ common_prefix = 0
+ for i in range(min(caller_len, candidate_len)):
+ if caller_parts[i] == candidate_parts[i]:
+ common_prefix += 1
+ else:
+ break
+ base_distance = max(caller_len, candidate_len) - common_prefix
+ if caller_parent_prefix and candidate_qn.startswith(caller_parent_prefix):
+ base_distance -= 1
+ return base_distance
+
def _resolve_class_name(self, class_name: str, module_qn: str) -> str | None:
return resolve_class_name(
class_name, module_qn, self.import_processor, self.function_registry
@@ -682,7 +1060,7 @@ def resolve_java_method_call(
self,
call_node: Node,
module_qn: str,
- local_var_types: dict[str, str],
+ local_var_types: dict[str, str] | None,
) -> tuple[str, str] | None:
java_engine = self.type_inference.java_type_inference
@@ -697,7 +1075,7 @@ def resolve_java_method_call(
else cs.TEXT_UNKNOWN
)
logger.debug(
- ls.CALL_JAVA_RESOLVED.format(call_text=call_text, method_qn=result[1])
+ ls.CALL_JAVA_RESOLVED, call_text=call_text, method_qn=result[1]
)
return result
diff --git a/codebase_rag/parsers/class_ingest/cpp_modules.py b/codebase_rag/parsers/class_ingest/cpp_modules.py
index a5db9bc47..afae6d901 100644
--- a/codebase_rag/parsers/class_ingest/cpp_modules.py
+++ b/codebase_rag/parsers/class_ingest/cpp_modules.py
@@ -8,6 +8,7 @@
from ... import constants as cs
from ... import logs
+from ...utils.path_utils import cached_relative_path, cached_resolve_posix
from ..utils import safe_decode_text, safe_decode_with_fallback
from .utils import decode_node_stripped
@@ -41,7 +42,7 @@ def ingest_cpp_module_declarations(
def _find_module_declarations(root_node: Node) -> list[tuple[Node, str]]:
module_declarations: list[tuple[Node, str]] = []
- def find_declarations(node: Node) -> None:
+ for node in root_node.children:
if node.type == cs.TS_MODULE_DECLARATION:
module_declarations.append((node, decode_node_stripped(node)))
elif node.type == cs.CppNodeType.DECLARATION:
@@ -56,10 +57,6 @@ def find_declarations(node: Node) -> None:
if has_module:
module_declarations.append((node, decode_node_stripped(node)))
- for child in node.children:
- find_declarations(child)
-
- find_declarations(root_node)
return module_declarations
@@ -83,7 +80,8 @@ def _process_export_module(
{
cs.KEY_QUALIFIED_NAME: interface_qn,
cs.KEY_NAME: module_name,
- cs.KEY_PATH: str(file_path.relative_to(repo_path)),
+ cs.KEY_PATH: cached_relative_path(file_path, repo_path).as_posix(),
+ cs.KEY_ABSOLUTE_PATH: cached_resolve_posix(file_path),
cs.KEY_MODULE_TYPE: cs.CPP_MODULE_TYPE_INTERFACE,
},
)
@@ -117,7 +115,8 @@ def _process_module_implementation(
{
cs.KEY_QUALIFIED_NAME: impl_qn,
cs.KEY_NAME: f"{module_name}{cs.CPP_IMPL_SUFFIX}",
- cs.KEY_PATH: str(file_path.relative_to(repo_path)),
+ cs.KEY_PATH: cached_relative_path(file_path, repo_path).as_posix(),
+ cs.KEY_ABSOLUTE_PATH: cached_resolve_posix(file_path),
cs.KEY_IMPLEMENTS_MODULE: module_name,
cs.KEY_MODULE_TYPE: cs.CPP_MODULE_TYPE_IMPLEMENTATION,
},
@@ -141,27 +140,27 @@ def _process_module_implementation(
def find_cpp_exported_classes(root_node: Node) -> list[Node]:
exported_class_nodes: list[Node] = []
+ stack = list(root_node.children)
- def traverse(node: Node) -> None:
+ while stack:
+ node = stack.pop()
if node.type == cs.CppNodeType.FUNCTION_DEFINITION:
node_text = decode_node_stripped(node)
if node_text.startswith(cs.CPP_EXPORT_PREFIXES):
+ found = False
for child in node.children:
if child.type == cs.TS_ERROR and child.text:
error_text = safe_decode_text(child)
if error_text in cs.CPP_EXPORTED_CLASS_KEYWORDS:
exported_class_nodes.append(node)
+ found = True
break
- else:
- if (
- cs.CPP_EXPORT_CLASS_PREFIX in node_text
- or cs.CPP_EXPORT_STRUCT_PREFIX in node_text
- ):
- exported_class_nodes.append(node)
-
- for child in node.children:
- traverse(child)
+ if not found and (
+ cs.CPP_EXPORT_CLASS_PREFIX in node_text
+ or cs.CPP_EXPORT_STRUCT_PREFIX in node_text
+ ):
+ exported_class_nodes.append(node)
+ stack.extend(node.children)
- traverse(root_node)
return exported_class_nodes
diff --git a/codebase_rag/parsers/class_ingest/identity.py b/codebase_rag/parsers/class_ingest/identity.py
index 85f670444..fc5ba13c6 100644
--- a/codebase_rag/parsers/class_ingest/identity.py
+++ b/codebase_rag/parsers/class_ingest/identity.py
@@ -7,7 +7,6 @@
from ... import constants as cs
from ...language_spec import LANGUAGE_FQN_SPECS
-from ...utils.fqn_resolver import resolve_fqn_from_ast
from ..cpp import utils as cpp_utils
from ..rs import utils as rs_utils
from ..utils import safe_decode_text
@@ -22,18 +21,23 @@ def resolve_class_identity(
language: cs.SupportedLanguage,
lang_config: LanguageSpec,
file_path: Path | None,
- repo_path: Path,
- project_name: str,
) -> tuple[str, str, bool] | None:
if (fqn_config := LANGUAGE_FQN_SPECS.get(language)) and file_path:
- if class_qn := resolve_fqn_from_ast(
- class_node,
- file_path,
- repo_path,
- project_name,
- fqn_config,
- ):
- class_name = class_qn.split(cs.SEPARATOR_DOT)[-1]
+ class_name = fqn_config.get_name(class_node)
+ if class_name:
+ parts = [class_name]
+ current = class_node.parent
+ while current:
+ if current.type in fqn_config.scope_node_types:
+ if scope_name := fqn_config.get_name(current):
+ parts.append(scope_name)
+ current = current.parent
+ parts.reverse()
+
+ # (H) Use the module's already-resolved (and collision-disambiguated)
+ # (H) qualified name as the prefix rather than recomputing from the path,
+ # (H) so same-stem cross-language siblings get distinct class/method qns.
+ class_qn = module_qn + cs.SEPARATOR_DOT + cs.SEPARATOR_DOT.join(parts)
is_exported = language == cs.SupportedLanguage.CPP and (
class_node.type == cs.CppNodeType.FUNCTION_DEFINITION
or cpp_utils.is_exported(class_node)
diff --git a/codebase_rag/parsers/class_ingest/method_override.py b/codebase_rag/parsers/class_ingest/method_override.py
index 686ff26e6..9dfc8bedf 100644
--- a/codebase_rag/parsers/class_ingest/method_override.py
+++ b/codebase_rag/parsers/class_ingest/method_override.py
@@ -66,9 +66,9 @@ def check_method_overrides(
(cs.NodeLabel.METHOD, cs.KEY_QUALIFIED_NAME, parent_method_qn),
)
logger.debug(
- logs.CLASS_METHOD_OVERRIDE.format(
- method_qn=method_qn, parent_method_qn=parent_method_qn
- )
+ logs.CLASS_METHOD_OVERRIDE,
+ method_qn=method_qn,
+ parent_method_qn=parent_method_qn,
)
return
diff --git a/codebase_rag/parsers/class_ingest/mixin.py b/codebase_rag/parsers/class_ingest/mixin.py
index 2ba3f8f8c..d2f189e00 100644
--- a/codebase_rag/parsers/class_ingest/mixin.py
+++ b/codebase_rag/parsers/class_ingest/mixin.py
@@ -1,6 +1,7 @@
from __future__ import annotations
from abc import abstractmethod
+from bisect import bisect_left, bisect_right
from pathlib import Path
from typing import TYPE_CHECKING
@@ -9,11 +10,14 @@
from ... import constants as cs
from ... import logs
+from ...config import settings
+from ...language_spec import LanguageSpec
from ...types_defs import ASTNode, PropertyDict
+from ...utils.path_utils import cached_relative_path, cached_resolve_posix
from ..java import utils as java_utils
from ..py import resolve_class_name
from ..rs import utils as rs_utils
-from ..utils import ingest_method, safe_decode_text
+from ..utils import ingest_method, safe_decode_text, sorted_captures
from . import cpp_modules
from . import identity as id_
from . import method_override as mo
@@ -21,7 +25,6 @@
from . import relationships as rel
if TYPE_CHECKING:
- from ...language_spec import LanguageSpec
from ...services import IngestorProtocol
from ...types_defs import (
FunctionRegistryTrieProtocol,
@@ -31,7 +34,46 @@
from ..import_processor import ImportProcessor
+def _is_nested_inside_function(
+ node: Node, class_body: Node, lang_config: LanguageSpec
+) -> bool:
+ current = node.parent
+ while current and current is not class_body:
+ if (
+ current.type in lang_config.function_node_types
+ and current.child_by_field_name(cs.FIELD_BODY) is not None
+ ):
+ return True
+ current = current.parent
+ return False
+
+
+def _method_belongs_directly(
+ method_node: Node, class_node: Node, lang_config: LanguageSpec
+) -> bool:
+ current = method_node.parent
+ while current is not None:
+ if current == class_node:
+ return True
+ if current.type in lang_config.class_node_types or (
+ current.type in lang_config.function_node_types
+ and current.child_by_field_name(cs.FIELD_BODY) is not None
+ ):
+ return False
+ current = current.parent
+ return False
+
+
+def _skip_method(
+ method_node: Node, class_node: Node, class_body: Node, lang_config: LanguageSpec
+) -> bool:
+ if settings.CAPTURE_FUNCTION_LOCAL_DEFINITIONS:
+ return not _method_belongs_directly(method_node, class_node, lang_config)
+ return _is_nested_inside_function(method_node, class_body, lang_config)
+
+
class ClassIngestMixin:
+ __slots__ = ()
ingestor: IngestorProtocol
repo_path: Path
project_name: str
@@ -47,6 +89,16 @@ def _get_docstring(self, node: ASTNode) -> str | None: ...
@abstractmethod
def _extract_decorators(self, node: ASTNode) -> list[str]: ...
+ @abstractmethod
+ def _determine_function_parent(
+ self,
+ func_node: Node,
+ func_qn: str,
+ module_qn: str,
+ lang_config: LanguageSpec,
+ language: cs.SupportedLanguage | None = None,
+ ) -> tuple[str, str]: ...
+
def _resolve_to_qn(self, name: str, module_qn: str) -> str:
return self._resolve_class_name(name, module_qn) or f"{module_qn}.{name}"
@@ -74,32 +126,44 @@ def _ingest_classes_and_methods(
module_qn: str,
language: cs.SupportedLanguage,
queries: dict[cs.SupportedLanguage, LanguageQueries],
+ combined_captures: dict[str, list] | None = None,
) -> None:
lang_queries = queries[language]
- if not (query := lang_queries[cs.QUERY_CLASSES]):
- return
-
lang_config: LanguageSpec = lang_queries[cs.QUERY_CONFIG]
- cursor = QueryCursor(query)
- captures = cursor.captures(root_node)
- class_nodes = captures.get(cs.CAPTURE_CLASS, [])
- module_nodes = captures.get(cs.ONEOF_MODULE, [])
+
+ if combined_captures is not None:
+ class_nodes = list(combined_captures.get(cs.CAPTURE_CLASS, []))
+ module_nodes = combined_captures.get(cs.ONEOF_MODULE, [])
+ else:
+ if not (query := lang_queries[cs.QUERY_CLASSES]):
+ return
+ cursor = QueryCursor(query)
+ captures = sorted_captures(cursor, root_node)
+ class_nodes = captures.get(cs.CAPTURE_CLASS, [])
+ module_nodes = captures.get(cs.ONEOF_MODULE, [])
if language == cs.SupportedLanguage.CPP:
class_nodes.extend(self._find_cpp_exported_classes(root_node))
file_path = self.module_qn_to_file_path.get(module_qn)
+ sorted_func_nodes: list[Node] | None = None
+ func_node_starts: list[int] | None = None
+ if combined_captures is not None and cs.CAPTURE_FUNCTION in combined_captures:
+ sorted_func_nodes = combined_captures[cs.CAPTURE_FUNCTION]
+ func_node_starts = [n.start_byte for n in sorted_func_nodes]
+
for class_node in class_nodes:
- if isinstance(class_node, Node):
- self._process_class_node(
- class_node,
- module_qn,
- language,
- lang_queries,
- lang_config,
- file_path,
- )
+ self._process_class_node(
+ class_node,
+ module_qn,
+ language,
+ lang_queries,
+ lang_config,
+ file_path,
+ sorted_func_nodes=sorted_func_nodes,
+ func_node_starts=func_node_starts,
+ )
self._process_inline_modules(module_nodes, module_qn, lang_config)
@@ -111,10 +175,17 @@ def _process_class_node(
lang_queries: LanguageQueries,
lang_config: LanguageSpec,
file_path: Path | None,
+ sorted_func_nodes: list[Node] | None = None,
+ func_node_starts: list[int] | None = None,
) -> None:
if language == cs.SupportedLanguage.RUST and class_node.type == cs.TS_IMPL_ITEM:
self._ingest_rust_impl_methods(
- class_node, module_qn, language, lang_queries
+ class_node,
+ module_qn,
+ language,
+ lang_queries,
+ sorted_func_nodes=sorted_func_nodes,
+ func_node_starts=func_node_starts,
)
return
@@ -124,13 +195,14 @@ def _process_class_node(
language,
lang_config,
file_path,
- self.repo_path,
- self.project_name,
)
if not identity:
return
class_qn, class_name, is_exported = identity
+ class_qn = self.function_registry.register_unique_qn(
+ class_qn, class_node.start_point[0] + 1
+ )
node_type = nt.determine_node_type(class_node, class_name, class_qn, language)
class_props: PropertyDict = {
@@ -142,15 +214,25 @@ def _process_class_node(
cs.KEY_DOCSTRING: self._get_docstring(class_node),
cs.KEY_IS_EXPORTED: is_exported,
}
+ if file_path is not None:
+ class_props[cs.KEY_PATH] = cached_relative_path(
+ file_path, self.repo_path
+ ).as_posix()
+ class_props[cs.KEY_ABSOLUTE_PATH] = cached_resolve_posix(file_path)
self.ingestor.ensure_node_batch(node_type, class_props)
self.function_registry[class_qn] = node_type
if class_name:
self.simple_name_lookup[class_name].add(class_qn)
+ parent_label, parent_qn = self._determine_function_parent(
+ class_node, class_qn, module_qn, lang_config, language
+ )
rel.create_class_relationships(
class_node,
class_qn,
module_qn,
+ parent_label,
+ parent_qn,
node_type,
is_exported,
language,
@@ -160,7 +242,15 @@ def _process_class_node(
self._resolve_to_qn,
self.function_registry,
)
- self._ingest_class_methods(class_node, class_qn, language, lang_queries)
+ self._ingest_class_methods(
+ class_node,
+ class_qn,
+ language,
+ lang_queries,
+ file_path,
+ sorted_func_nodes=sorted_func_nodes,
+ func_node_starts=func_node_starts,
+ )
def _ingest_rust_impl_methods(
self,
@@ -168,31 +258,83 @@ def _ingest_rust_impl_methods(
module_qn: str,
language: cs.SupportedLanguage,
lang_queries: LanguageQueries,
+ sorted_func_nodes: list[Node] | None = None,
+ func_node_starts: list[int] | None = None,
) -> None:
if not (impl_target := rs_utils.extract_impl_target(class_node)):
return
- class_qn = f"{module_qn}.{impl_target}"
+ # (H) An impl block inside `mod inner` targets a type whose node lives
+ # (H) under the module path (proj...inner.Widget). Resolve the impl target
+ # (H) against its enclosing module so the method binds to the real type
+ # (H) node instead of a phantom under the file module.
+ mod_parts = rs_utils.build_module_path(class_node)
+ owner_module_qn = (
+ f"{module_qn}{cs.SEPARATOR_DOT}{cs.SEPARATOR_DOT.join(mod_parts)}"
+ if mod_parts
+ else module_qn
+ )
+ class_qn = f"{owner_module_qn}.{impl_target}"
+
+ # (H) `impl Trait for Type` means Type IMPLEMENTS Trait. The target type's
+ # (H) node label may be Class/Enum/Type, so match the relationship source
+ # (H) to its registered label (else the IMPLEMENTS edge never resolves).
+ if trait_name := rs_utils.extract_impl_trait(class_node):
+ owner_type = self.function_registry.get(class_qn)
+ owner_label = (
+ cs.NodeLabel(owner_type.value)
+ if owner_type is not None
+ else cs.NodeLabel.CLASS
+ )
+ self.ingestor.ensure_relationship_batch(
+ (owner_label, cs.KEY_QUALIFIED_NAME, class_qn),
+ cs.RelationshipType.IMPLEMENTS,
+ (
+ cs.NodeLabel.INTERFACE,
+ cs.KEY_QUALIFIED_NAME,
+ self._resolve_to_qn(trait_name, owner_module_qn),
+ ),
+ )
+
body_node = class_node.child_by_field_name("body")
- method_query = lang_queries[cs.QUERY_FUNCTIONS]
- if not body_node or not method_query:
+ if not body_node:
return
- method_cursor = QueryCursor(method_query)
- method_captures = method_cursor.captures(body_node)
- for method_node in method_captures.get(cs.CAPTURE_FUNCTION, []):
- if isinstance(method_node, Node):
- ingest_method(
- method_node,
- class_qn,
- cs.NodeLabel.CLASS,
- self.ingestor,
- self.function_registry,
- self.simple_name_lookup,
- self._get_docstring,
- language,
- )
+ file_path = self.module_qn_to_file_path.get(module_qn)
+ lang_config: LanguageSpec = lang_queries[cs.QUERY_CONFIG]
+
+ if sorted_func_nodes is not None and func_node_starts is not None:
+ body_start = body_node.start_byte
+ body_end = body_node.end_byte
+ lo = bisect_left(func_node_starts, body_start)
+ hi = bisect_right(func_node_starts, body_end)
+ method_nodes = [
+ n for n in sorted_func_nodes[lo:hi] if n.end_byte <= body_end
+ ]
+ else:
+ method_query = lang_queries[cs.QUERY_FUNCTIONS]
+ if not method_query:
+ return
+ method_cursor = QueryCursor(method_query)
+ method_captures = sorted_captures(method_cursor, body_node)
+ method_nodes = method_captures.get(cs.CAPTURE_FUNCTION, [])
+
+ for method_node in method_nodes:
+ if _skip_method(method_node, class_node, body_node, lang_config):
+ continue
+ ingest_method(
+ method_node,
+ class_qn,
+ cs.NodeLabel.CLASS,
+ self.ingestor,
+ self.function_registry,
+ self.simple_name_lookup,
+ self._get_docstring,
+ language,
+ file_path=file_path,
+ repo_path=self.repo_path,
+ )
def _ingest_class_methods(
self,
@@ -200,16 +342,34 @@ def _ingest_class_methods(
class_qn: str,
language: cs.SupportedLanguage,
lang_queries: LanguageQueries,
+ file_path: Path | None = None,
+ sorted_func_nodes: list[Node] | None = None,
+ func_node_starts: list[int] | None = None,
) -> None:
body_node = class_node.child_by_field_name("body")
- method_query = lang_queries[cs.QUERY_FUNCTIONS]
- if not body_node or not method_query:
+ if not body_node:
return
- method_cursor = QueryCursor(method_query)
- method_captures = method_cursor.captures(body_node)
- for method_node in method_captures.get(cs.CAPTURE_FUNCTION, []):
- if not isinstance(method_node, Node):
+ lang_config: LanguageSpec = lang_queries[cs.QUERY_CONFIG]
+
+ if sorted_func_nodes is not None and func_node_starts is not None:
+ body_start = body_node.start_byte
+ body_end = body_node.end_byte
+ lo = bisect_left(func_node_starts, body_start)
+ hi = bisect_right(func_node_starts, body_end)
+ method_nodes = [
+ n for n in sorted_func_nodes[lo:hi] if n.end_byte <= body_end
+ ]
+ else:
+ method_query = lang_queries[cs.QUERY_FUNCTIONS]
+ if not method_query:
+ return
+ method_cursor = QueryCursor(method_query)
+ method_captures = sorted_captures(method_cursor, body_node)
+ method_nodes = method_captures.get(cs.CAPTURE_FUNCTION, [])
+
+ for method_node in method_nodes:
+ if _skip_method(method_node, class_node, body_node, lang_config):
continue
method_qualified_name = None
@@ -233,6 +393,8 @@ def _ingest_class_methods(
language,
self._extract_decorators,
method_qualified_name,
+ file_path=file_path,
+ repo_path=self.repo_path,
)
def _process_inline_modules(
@@ -249,6 +411,13 @@ def _process_inline_modules(
if not module_name_node.text:
continue
+ # (H) A bodyless `mod foo;` only declares that the file module foo.rs
+ # (H) belongs here; foo.rs already yields its own real-path Module node
+ # (H) with the same qn. Emitting a second synthetic-path node collides
+ # (H) on that qn and clobbers the file's real path, so skip it.
+ if module_node.child_by_field_name(cs.FIELD_BODY) is None:
+ continue
+
module_name = safe_decode_text(module_name_node)
nested_qn = id_.build_nested_qualified_name_for_class(
module_node, module_qn, module_name or "", lang_config
@@ -259,7 +428,17 @@ def _process_inline_modules(
cs.KEY_QUALIFIED_NAME: inline_module_qn,
cs.KEY_NAME: module_name,
cs.KEY_PATH: f"{cs.INLINE_MODULE_PATH_PREFIX}{module_name}",
+ cs.KEY_START_LINE: module_node.start_point[0] + 1,
+ cs.KEY_END_LINE: module_node.end_point[0] + 1,
}
+ # (H) A bodied inline module is physically located in this file; give
+ # (H) it the real path so it joins containment on (file, line).
+ file_path = self.module_qn_to_file_path.get(module_qn)
+ if file_path is not None:
+ module_props[cs.KEY_PATH] = cached_relative_path(
+ file_path, self.repo_path
+ ).as_posix()
+ module_props[cs.KEY_ABSOLUTE_PATH] = cached_resolve_posix(file_path)
logger.info(
logs.CLASS_FOUND_INLINE_MODULE.format(
name=module_name, qn=inline_module_qn
@@ -267,6 +446,17 @@ def _process_inline_modules(
)
self.ingestor.ensure_node_batch(cs.NodeLabel.MODULE, module_props)
+ # (H) Link the inline module into the containment tree: its enclosing
+ # (H) module (file module, or an outer mod) DEFINES it. Without this the
+ # (H) inline Module node is an orphan defining nothing.
+ parent_module_qn = inline_module_qn.rsplit(cs.SEPARATOR_DOT, 1)[0]
+ if parent_module_qn and parent_module_qn != inline_module_qn:
+ self.ingestor.ensure_relationship_batch(
+ (cs.NodeLabel.MODULE, cs.KEY_QUALIFIED_NAME, parent_module_qn),
+ cs.RelationshipType.DEFINES,
+ (cs.NodeLabel.MODULE, cs.KEY_QUALIFIED_NAME, inline_module_qn),
+ )
+
def process_all_method_overrides(self) -> None:
mo.process_all_method_overrides(
self.function_registry,
diff --git a/codebase_rag/parsers/class_ingest/node_type.py b/codebase_rag/parsers/class_ingest/node_type.py
index 8cdf66d78..7485ab66b 100644
--- a/codebase_rag/parsers/class_ingest/node_type.py
+++ b/codebase_rag/parsers/class_ingest/node_type.py
@@ -16,19 +16,28 @@ def determine_node_type(
language: cs.SupportedLanguage,
) -> NodeType:
match class_node.type:
- case cs.TS_INTERFACE_DECLARATION:
+ case cs.TS_GO_TYPE_SPEC | cs.TS_GO_TYPE_ALIAS if (
+ language == cs.SupportedLanguage.GO
+ ):
+ return _go_type_node_type(class_node, class_name, class_qn)
+ case cs.TS_INTERFACE_DECLARATION | cs.TS_RS_TRAIT_ITEM:
logger.info(logs.CLASS_FOUND_INTERFACE.format(name=class_name, qn=class_qn))
return NodeType.INTERFACE
- case cs.TS_ENUM_DECLARATION | cs.TS_ENUM_SPECIFIER | cs.TS_ENUM_CLASS_SPECIFIER:
+ case (
+ cs.TS_ENUM_DECLARATION
+ | cs.TS_ENUM_SPECIFIER
+ | cs.TS_ENUM_CLASS_SPECIFIER
+ | cs.TS_RS_ENUM_ITEM
+ ):
logger.info(logs.CLASS_FOUND_ENUM.format(name=class_name, qn=class_qn))
return NodeType.ENUM
- case cs.TS_TYPE_ALIAS_DECLARATION:
+ case cs.TS_TYPE_ALIAS_DECLARATION | cs.TS_RS_TYPE_ITEM:
logger.info(logs.CLASS_FOUND_TYPE.format(name=class_name, qn=class_qn))
return NodeType.TYPE
- case cs.TS_STRUCT_SPECIFIER:
+ case cs.TS_STRUCT_SPECIFIER | cs.TS_RS_STRUCT_ITEM:
logger.info(logs.CLASS_FOUND_STRUCT.format(name=class_name, qn=class_qn))
return NodeType.CLASS
- case cs.TS_UNION_SPECIFIER:
+ case cs.TS_UNION_SPECIFIER | cs.TS_RS_UNION_ITEM:
logger.info(logs.CLASS_FOUND_UNION.format(name=class_name, qn=class_qn))
return NodeType.UNION
case cs.CppNodeType.TEMPLATE_DECLARATION:
@@ -47,6 +56,22 @@ def determine_node_type(
return NodeType.CLASS
+def _go_type_node_type(
+ class_node: Node, class_name: str | None, class_qn: str
+) -> NodeType:
+ underlying = class_node.child_by_field_name(cs.FIELD_TYPE)
+ match underlying.type if underlying else None:
+ case cs.TS_GO_STRUCT_TYPE:
+ logger.info(logs.CLASS_FOUND_STRUCT.format(name=class_name, qn=class_qn))
+ return NodeType.CLASS
+ case cs.TS_GO_INTERFACE_TYPE:
+ logger.info(logs.CLASS_FOUND_INTERFACE.format(name=class_name, qn=class_qn))
+ return NodeType.INTERFACE
+ case _:
+ logger.info(logs.CLASS_FOUND_TYPE.format(name=class_name, qn=class_qn))
+ return NodeType.TYPE
+
+
def log_exported_class_type(
class_node: Node, class_name: str | None, class_qn: str
) -> None:
diff --git a/codebase_rag/parsers/class_ingest/parent_extraction.py b/codebase_rag/parsers/class_ingest/parent_extraction.py
index 289e82c35..fd8673748 100644
--- a/codebase_rag/parsers/class_ingest/parent_extraction.py
+++ b/codebase_rag/parsers/class_ingest/parent_extraction.py
@@ -16,6 +16,21 @@
from ..import_processor import ImportProcessor
+def php_base_simple_name(node: Node) -> str | None:
+ # (H) A PHP base type is a plain `name` (`Base`) or a `qualified_name`
+ # (H) (`\Exception`, `\App\Base`) whose trailing `name` child is the simple
+ # (H) name; cgr resolves bases by simple name.
+ if node.type == cs.TS_PHP_NAME and node.text:
+ return safe_decode_text(node)
+ if node.type == cs.TS_PHP_QUALIFIED_NAME:
+ last: Node | None = None
+ for child in node.children:
+ if child.type == cs.TS_PHP_NAME:
+ last = child
+ return safe_decode_text(last) if last and last.text else None
+ return None
+
+
def extract_parent_classes(
class_node: Node,
module_qn: str,
@@ -52,6 +67,22 @@ def extract_parent_classes(
)
)
+ # (H) PHP `extends` (a class's superclass or an interface's superinterfaces)
+ # (H) is a base_clause listing `name` nodes; both are inheritance.
+ if base_clause := find_child_by_type(class_node, cs.TS_PHP_BASE_CLAUSE):
+ for child in base_clause.children:
+ if parent_name := php_base_simple_name(child):
+ parent_classes.append(resolve_to_qn(parent_name, module_qn))
+
+ # (H) Rust supertrait bound (`trait Sub: Super`) is inheritance between traits.
+ if class_node.type == cs.TS_RS_TRAIT_ITEM:
+ if bounds := class_node.child_by_field_name(cs.FIELD_BOUNDS):
+ for child in bounds.children:
+ base = java_base_type_identifier(child)
+ if base is not None and base.text:
+ if name := safe_decode_text(base):
+ parent_classes.append(resolve_to_qn(name, module_qn))
+
return parent_classes
@@ -90,9 +121,9 @@ def parse_cpp_base_classes(
)
parent_classes.append(parent_qn)
logger.debug(
- logs.CLASS_CPP_INHERITANCE.format(
- parent_name=parent_name, parent_qn=parent_qn
- )
+ logs.CLASS_CPP_INHERITANCE,
+ parent_name=parent_name,
+ parent_qn=parent_qn,
)
return parent_classes
@@ -108,13 +139,38 @@ def extract_cpp_base_class_name(parent_text: str) -> str:
return parent_text
+def java_base_type_identifier(type_node: Node) -> Node | None:
+ # (H) The base type in a Java extends/implements clause may be plain
+ # (H) (`Base`), generic (`Base` -> generic_type), or qualified
+ # (H) (`pkg.Base` -> scoped_type_identifier). Unwrap to the base type's
+ # (H) type_identifier so generic/qualified bases are captured, not dropped.
+ if type_node.type == cs.TS_TYPE_IDENTIFIER:
+ return type_node
+ if type_node.type == cs.TS_GENERIC_TYPE:
+ for child in type_node.children:
+ if child.type in (
+ cs.TS_TYPE_IDENTIFIER,
+ cs.TS_RS_SCOPED_TYPE_IDENTIFIER,
+ ):
+ return java_base_type_identifier(child)
+ if type_node.type == cs.TS_RS_SCOPED_TYPE_IDENTIFIER:
+ # (H) `a.b.Base` -> the trailing type_identifier is the simple name.
+ last: Node | None = None
+ for child in type_node.children:
+ if child.type == cs.TS_TYPE_IDENTIFIER:
+ last = child
+ return last
+ return None
+
+
def resolve_superclass_from_type_identifier(
type_identifier_node: Node,
module_qn: str,
resolve_to_qn: Callable[[str, str], str],
) -> str | None:
- if type_identifier_node.text:
- if parent_name := safe_decode_text(type_identifier_node):
+ base = java_base_type_identifier(type_identifier_node)
+ if base is not None and base.text:
+ if parent_name := safe_decode_text(base):
return resolve_to_qn(parent_name, module_qn)
return None
@@ -128,7 +184,12 @@ def extract_java_superclass(
if not superclass_node:
return []
- if superclass_node.type == cs.TS_TYPE_IDENTIFIER:
+ _JAVA_BASE_TYPES = (
+ cs.TS_TYPE_IDENTIFIER,
+ cs.TS_GENERIC_TYPE,
+ cs.TS_RS_SCOPED_TYPE_IDENTIFIER,
+ )
+ if superclass_node.type in _JAVA_BASE_TYPES:
if resolved := resolve_superclass_from_type_identifier(
superclass_node, module_qn, resolve_to_qn
):
@@ -136,7 +197,7 @@ def extract_java_superclass(
return []
for child in superclass_node.children:
- if child.type == cs.TS_TYPE_IDENTIFIER:
+ if child.type in _JAVA_BASE_TYPES:
if resolved := resolve_superclass_from_type_identifier(
child, module_qn, resolve_to_qn
):
@@ -158,17 +219,19 @@ def extract_python_superclasses(
import_map = import_processor.import_mapping.get(module_qn)
for child in superclasses_node.children:
- if child.type != cs.TS_IDENTIFIER or not child.text:
+ if child.type not in (cs.TS_IDENTIFIER, cs.TS_PY_ATTRIBUTE) or not child.text:
continue
if not (parent_name := safe_decode_text(child)):
continue
- if import_map and parent_name in import_map:
- parent_classes.append(import_map[parent_name])
+ head, sep, tail = parent_name.partition(cs.SEPARATOR_DOT)
+ if import_map and head in import_map:
+ resolved_head = import_map[head]
elif import_map:
- parent_classes.append(resolve_to_qn(parent_name, module_qn))
+ resolved_head = resolve_to_qn(head, module_qn)
else:
- parent_classes.append(f"{module_qn}.{parent_name}")
+ resolved_head = f"{module_qn}.{head}"
+ parent_classes.append(f"{resolved_head}{sep}{tail}")
return parent_classes
@@ -238,6 +301,13 @@ def extract_interface_parents(
import_processor: ImportProcessor,
resolve_to_qn: Callable[[str, str], str],
) -> list[str]:
+ # (H) Java interface `extends A, B` is an `extends_interfaces` clause holding a
+ # (H) type_list; superinterfaces are inheritance, so emit them as INHERITS.
+ if java_extends := find_child_by_type(class_node, cs.TS_JAVA_EXTENDS_INTERFACES):
+ parents: list[str] = []
+ extract_java_interface_names(java_extends, parents, module_qn, resolve_to_qn)
+ return parents
+
extends_clause = find_child_by_type(class_node, cs.TS_EXTENDS_TYPE_CLAUSE)
if not extends_clause:
return []
@@ -310,6 +380,23 @@ def extract_implemented_interfaces(
interfaces_node, implemented_interfaces, module_qn, resolve_to_qn
)
+ # (H) TypeScript `class C implements I, J` lives in class_heritage >
+ # (H) implements_clause (no `interfaces` field), holding type_identifiers.
+ if class_heritage := find_child_by_type(class_node, cs.TS_CLASS_HERITAGE):
+ if implements_clause := find_child_by_type(
+ class_heritage, cs.TS_IMPLEMENTS_CLAUSE
+ ):
+ for child in implements_clause.children:
+ if child.type == cs.TS_TYPE_IDENTIFIER and child.text:
+ if name := safe_decode_text(child):
+ implemented_interfaces.append(resolve_to_qn(name, module_qn))
+
+ # (H) PHP `class C implements I, J` is a class_interface_clause of `name` nodes.
+ if php_impl := find_child_by_type(class_node, cs.TS_PHP_CLASS_INTERFACE_CLAUSE):
+ for child in php_impl.children:
+ if name := php_base_simple_name(child):
+ implemented_interfaces.append(resolve_to_qn(name, module_qn))
+
return implemented_interfaces
@@ -322,6 +409,10 @@ def extract_java_interface_names(
for child in interfaces_node.children:
if child.type == cs.TS_TYPE_LIST:
for type_child in child.children:
- if type_child.type == cs.TS_TYPE_IDENTIFIER and type_child.text:
- if interface_name := safe_decode_text(type_child):
+ # (H) Unwrap generic/qualified bases (`TBase`, `pkg.IScheme`) to
+ # (H) the base type_identifier; plain identifiers pass straight
+ # (H) through. Skips list punctuation (commas).
+ base = java_base_type_identifier(type_child)
+ if base is not None and base.text:
+ if interface_name := safe_decode_text(base):
interface_list.append(resolve_to_qn(interface_name, module_qn))
diff --git a/codebase_rag/parsers/class_ingest/relationships.py b/codebase_rag/parsers/class_ingest/relationships.py
index 6af794fac..07daccf37 100644
--- a/codebase_rag/parsers/class_ingest/relationships.py
+++ b/codebase_rag/parsers/class_ingest/relationships.py
@@ -19,6 +19,8 @@ def create_class_relationships(
class_node: Node,
class_qn: str,
module_qn: str,
+ parent_label: str,
+ parent_qn: str,
node_type: NodeType,
is_exported: bool,
language: cs.SupportedLanguage,
@@ -34,7 +36,7 @@ def create_class_relationships(
class_inheritance[class_qn] = parent_classes
ingestor.ensure_relationship_batch(
- (cs.NodeLabel.MODULE, cs.KEY_QUALIFIED_NAME, module_qn),
+ (parent_label, cs.KEY_QUALIFIED_NAME, parent_qn),
cs.RelationshipType.DEFINES,
(node_type, cs.KEY_QUALIFIED_NAME, class_qn),
)
@@ -51,7 +53,9 @@ def create_class_relationships(
node_type, class_qn, parent_class_qn, function_registry, ingestor
)
- if class_node.type == cs.TS_CLASS_DECLARATION:
+ # (H) A class OR an enum can `implements` interfaces; both expose them via the
+ # (H) `interfaces` field (a super_interfaces clause), so handle both.
+ if class_node.type in (cs.TS_CLASS_DECLARATION, cs.TS_ENUM_DECLARATION):
for interface_qn in pe.extract_implemented_interfaces(
class_node, module_qn, resolve_to_qn
):
diff --git a/codebase_rag/parsers/cpp/utils.py b/codebase_rag/parsers/cpp/utils.py
index de9669a33..c5b813d45 100644
--- a/codebase_rag/parsers/cpp/utils.py
+++ b/codebase_rag/parsers/cpp/utils.py
@@ -57,35 +57,43 @@ def build_qualified_name(node: Node, module_qn: str, name: str) -> str:
return cs.SEPARATOR_DOT.join([module_qn, name])
+_EXPORT_CANDIDATE_TYPES = frozenset(
+ {
+ cs.CppNodeType.EXPORT,
+ cs.CppNodeType.EXPORT_KEYWORD,
+ cs.CppNodeType.IDENTIFIER,
+ cs.CppNodeType.PRIMITIVE_TYPE,
+ }
+)
+
+_EXPORT_STOP_TYPES = frozenset(
+ {
+ cs.CppNodeType.DECLARATION,
+ cs.CppNodeType.FUNCTION_DEFINITION,
+ cs.CppNodeType.TEMPLATE_DECLARATION,
+ cs.CppNodeType.CLASS_SPECIFIER,
+ cs.CppNodeType.TRANSLATION_UNIT,
+ }
+)
+
+
def is_exported(node: Node) -> bool:
current = node
+ export_text = cs.CppNodeType.EXPORT
while current and current.parent:
parent = current.parent
- found_export = False
for child in parent.children:
if child == current:
break
- if child.text:
- child_text = safe_decode_text(child)
- if child_text == cs.CppNodeType.EXPORT and child.type in (
- cs.CppNodeType.EXPORT,
- cs.CppNodeType.EXPORT_KEYWORD,
- cs.CppNodeType.IDENTIFIER,
- cs.CppNodeType.PRIMITIVE_TYPE,
- ):
- found_export = True
-
- if found_export:
- return True
+ if (
+ child.type in _EXPORT_CANDIDATE_TYPES
+ and child.text
+ and safe_decode_text(child) == export_text
+ ):
+ return True
- if current.type in (
- cs.CppNodeType.DECLARATION,
- cs.CppNodeType.FUNCTION_DEFINITION,
- cs.CppNodeType.TEMPLATE_DECLARATION,
- cs.CppNodeType.CLASS_SPECIFIER,
- cs.CppNodeType.TRANSLATION_UNIT,
- ):
+ if current.type in _EXPORT_STOP_TYPES:
break
current = current.parent
diff --git a/codebase_rag/parsers/cpp_frontend/__init__.py b/codebase_rag/parsers/cpp_frontend/__init__.py
new file mode 100644
index 000000000..eb67d2372
--- /dev/null
+++ b/codebase_rag/parsers/cpp_frontend/__init__.py
@@ -0,0 +1,14 @@
+from .frontend import (
+ cpp_frontend_available,
+ find_compile_commands,
+ run_cpp_frontend,
+)
+from .qn import CppQnResolver, build_module_qn_map
+
+__all__ = [
+ "CppQnResolver",
+ "build_module_qn_map",
+ "cpp_frontend_available",
+ "find_compile_commands",
+ "run_cpp_frontend",
+]
diff --git a/codebase_rag/parsers/cpp_frontend/constants.py b/codebase_rag/parsers/cpp_frontend/constants.py
new file mode 100644
index 000000000..06c2f7735
--- /dev/null
+++ b/codebase_rag/parsers/cpp_frontend/constants.py
@@ -0,0 +1,39 @@
+from __future__ import annotations
+
+from ... import constants as cs
+
+# (H) libclang CursorKind members are registered dynamically (not static class
+# (H) attributes), so they are matched by the stable NAME string that
+# (H) `cursor.kind.name` yields at runtime, never via `ci.CursorKind.CLASS_DECL`
+# (H) (which trips ty's unresolved-attribute). Same approach as the eval oracle
+# (H) (evals/oracles/cpp_oracle.py).
+
+KIND_NAMESPACE = "NAMESPACE"
+KIND_DESTRUCTOR = "DESTRUCTOR"
+KIND_BASE_SPECIFIER = "CXX_BASE_SPECIFIER"
+KIND_TRANSLATION_UNIT = "TRANSLATION_UNIT"
+KIND_CALL_EXPR = "CALL_EXPR"
+
+# (H) class/struct/union and their templated forms -> a Class node (cgr collapses
+# (H) struct/class to Class, matching parsers/cpp + the oracle).
+CLASS_KIND_NAMES: frozenset[str] = frozenset(
+ {"CLASS_DECL", "STRUCT_DECL", "CLASS_TEMPLATE"}
+)
+# (H) free functions and function templates -> a Function node, UNLESS their
+# (H) semantic parent is a class (a templated method is a FUNCTION_TEMPLATE whose
+# (H) parent is the class), in which case they are Methods.
+FUNCTION_KIND_NAMES: frozenset[str] = frozenset({"FUNCTION_DECL", "FUNCTION_TEMPLATE"})
+# (H) members -> a Method node.
+METHOD_KIND_NAMES: frozenset[str] = frozenset(
+ {"CXX_METHOD", "CONSTRUCTOR", "DESTRUCTOR", "CONVERSION_FUNCTION"}
+)
+# (H) `using Alias = T;` (TYPE_ALIAS_DECL) and `typedef T Alias;` (TYPEDEF_DECL)
+# (H) -> a Type node, matching how the tree-sitter path maps C++ alias/typedef
+# (H) declarations (TS_TYPE_ALIAS_DECLARATION) and Go/Rust type decls.
+TYPE_KIND_NAMES: frozenset[str] = frozenset({"TYPE_ALIAS_DECL", "TYPEDEF_DECL"})
+
+LABEL_MODULE = cs.NodeLabel.MODULE.value
+LABEL_CLASS = cs.NodeLabel.CLASS.value
+LABEL_FUNCTION = cs.NodeLabel.FUNCTION.value
+LABEL_METHOD = cs.NodeLabel.METHOD.value
+LABEL_TYPE = cs.NodeLabel.TYPE.value
diff --git a/codebase_rag/parsers/cpp_frontend/frontend.py b/codebase_rag/parsers/cpp_frontend/frontend.py
new file mode 100644
index 000000000..4208b708b
--- /dev/null
+++ b/codebase_rag/parsers/cpp_frontend/frontend.py
@@ -0,0 +1,364 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from ... import constants as cs
+from ...services import IngestorProtocol
+from ...types_defs import (
+ FunctionRegistryTrieProtocol,
+ NodeType,
+ PropertyDict,
+ SimpleNameLookup,
+)
+from . import constants as fc
+from .qn import CppQnResolver
+
+if TYPE_CHECKING:
+ from clang.cindex import Cursor
+
+_NodeKey = tuple[str, str]
+_EdgeKey = tuple[str, str, str, str, str]
+_Scope = tuple[str, str] | None
+
+_COMPILE_COMMANDS = "compile_commands.json"
+_BUILD_DIR = "build"
+
+
+def cpp_frontend_available() -> bool:
+ try:
+ import clang.cindex as ci
+
+ ci.Index.create()
+ except Exception:
+ return False
+ return True
+
+
+def find_compile_commands(start: Path) -> Path | None:
+ # (H) Discover the directory holding a compile_commands.json: the indexed
+ # (H) target, a conventional build/ subdir, then walking up to the repo root.
+ start = start.resolve()
+ seen: set[Path] = set()
+ for candidate in (start, start / _BUILD_DIR, *start.parents):
+ if candidate in seen:
+ continue
+ seen.add(candidate)
+ if (candidate / _COMPILE_COMMANDS).is_file():
+ return candidate
+ return None
+
+
+def _base_simple_name(spelling: str) -> str:
+ flat = spelling.replace(cs.SEPARATOR_DOUBLE_COLON, cs.SEPARATOR_DOT)
+ return flat.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+
+
+def _classify(cursor: Cursor) -> str | None:
+ kind = cursor.kind.name
+ if kind in fc.CLASS_KIND_NAMES:
+ return fc.LABEL_CLASS
+ if kind in fc.TYPE_KIND_NAMES:
+ return fc.LABEL_TYPE
+ if kind in fc.METHOD_KIND_NAMES:
+ return fc.LABEL_METHOD
+ if kind in fc.FUNCTION_KIND_NAMES:
+ parent = cursor.semantic_parent
+ if parent is not None and parent.kind.name in fc.CLASS_KIND_NAMES:
+ return fc.LABEL_METHOD
+ return fc.LABEL_FUNCTION
+ return None
+
+
+class _Collector:
+ def __init__(
+ self,
+ resolver: CppQnResolver,
+ function_registry: FunctionRegistryTrieProtocol | None = None,
+ simple_name_lookup: SimpleNameLookup | None = None,
+ structural_elements: dict[Path, str | None] | None = None,
+ ) -> None:
+ self.resolver = resolver
+ self.function_registry = function_registry
+ self.simple_name_lookup = simple_name_lookup
+ self.structural_elements = structural_elements
+ self.nodes: dict[_NodeKey, tuple[str, PropertyDict, bool]] = {}
+ self.modules: dict[str, PropertyDict] = {}
+ self.edges: set[_EdgeKey] = set()
+ self.covered: set[str] = set()
+
+ def _node_props(self, cursor: Cursor, qn: str, name: str, rel: str) -> PropertyDict:
+ return {
+ cs.KEY_QUALIFIED_NAME: qn,
+ cs.KEY_NAME: name,
+ cs.KEY_DECORATORS: [],
+ cs.KEY_START_LINE: cursor.location.line,
+ cs.KEY_END_LINE: cursor.extent.end.line,
+ cs.KEY_DOCSTRING: None,
+ cs.KEY_IS_EXPORTED: False,
+ cs.KEY_PATH: rel,
+ cs.KEY_ABSOLUTE_PATH: Path(cursor.location.file.name).resolve().as_posix(),
+ }
+
+ def _add_node(self, label: str, qn: str, props: PropertyDict, is_def: bool) -> None:
+ key: _NodeKey = (label, qn)
+ existing = self.nodes.get(key)
+ # (H) Prefer the definition cursor's properties (its span is the accurate
+ # (H) one) over a mere declaration's, matching cgr where the deferred
+ # (H) out-of-line definition is ingested last and wins the MERGE.
+ if existing is None or (is_def and not existing[2]):
+ self.nodes[key] = (label, props, is_def)
+
+ def _add_module(self, module_qn: str, rel: str, absolute_file: str) -> None:
+ if module_qn in self.modules:
+ return
+ self.modules[module_qn] = {
+ cs.KEY_QUALIFIED_NAME: module_qn,
+ cs.KEY_NAME: Path(rel).name,
+ cs.KEY_PATH: rel,
+ cs.KEY_ABSOLUTE_PATH: Path(absolute_file).resolve().as_posix(),
+ }
+
+ def _add_edge(
+ self, rel_type: str, from_label: str, from_qn: str, to_label: str, to_qn: str
+ ) -> None:
+ self.edges.add((rel_type, from_label, from_qn, to_label, to_qn))
+
+ def process(self, cursor: Cursor, enclosing: _Scope) -> _Scope:
+ # (H) Returns the scope its subtree should attribute calls to: the node's
+ # (H) own (label, qn) when it is a function/method, else the unchanged
+ # (H) enclosing scope.
+ if cursor.kind.name == fc.KIND_CALL_EXPR:
+ self._process_call(cursor, enclosing)
+ return None
+ label = _classify(cursor)
+ if label is None or cursor.location.file is None:
+ return None
+ if label == fc.LABEL_CLASS and not cursor.is_definition():
+ return None # (H) forward declarations are not nodes
+ rel = self.resolver.rel_path(cursor.location.file.name)
+ module_qn = self.resolver.module_qn(cursor.location.file.name)
+ if rel is None or module_qn is None:
+ return None # (H) outside the indexed repo (system headers, etc.)
+
+ if label == fc.LABEL_METHOD:
+ return self._process_method(cursor, rel)
+ if label == fc.LABEL_TYPE:
+ self._process_type(cursor, rel, module_qn)
+ return None
+
+ qn = (
+ self.resolver.class_qn(cursor)
+ if label == fc.LABEL_CLASS
+ else self.resolver.function_qn(cursor)
+ )
+ if qn is None:
+ return None
+ self.covered.add(rel)
+ self._add_module(module_qn, rel, cursor.location.file.name)
+ self._add_node(
+ label,
+ qn,
+ self._node_props(cursor, qn, cursor.spelling, rel),
+ cursor.is_definition(),
+ )
+ self._add_edge(
+ cs.RelationshipType.DEFINES, fc.LABEL_MODULE, module_qn, label, qn
+ )
+ if label == fc.LABEL_CLASS:
+ self._emit_inheritance(cursor, qn)
+ return None
+ return (label, qn)
+
+ def _process_method(self, cursor: Cursor, rel: str) -> _Scope:
+ qn = self.resolver.method_qn(cursor)
+ parent = cursor.semantic_parent
+ if qn is None or parent is None:
+ return None
+ class_qn = self.resolver.class_qn(parent)
+ if class_qn is None:
+ return None
+ self.covered.add(rel)
+ name = self.resolver.member_name(cursor)
+ self._add_node(
+ fc.LABEL_METHOD,
+ qn,
+ self._node_props(cursor, qn, name, rel),
+ cursor.is_definition(),
+ )
+ self._add_edge(
+ cs.RelationshipType.DEFINES_METHOD,
+ fc.LABEL_CLASS,
+ class_qn,
+ fc.LABEL_METHOD,
+ qn,
+ )
+ return (fc.LABEL_METHOD, qn)
+
+ def _process_type(self, cursor: Cursor, rel: str, module_qn: str) -> None:
+ # (H) A `using`/`typedef` alias becomes a Type node, DEFINED by its
+ # (H) enclosing Class (member alias) or its Module (namespace/file scope),
+ # (H) matching the tree-sitter alias path and Go/Rust type decls.
+ qn = self.resolver.type_qn(cursor)
+ if qn is None:
+ return
+ self.covered.add(rel)
+ self._add_module(module_qn, rel, cursor.location.file.name)
+ self._add_node(
+ fc.LABEL_TYPE,
+ qn,
+ self._node_props(cursor, qn, cursor.spelling, rel),
+ cursor.is_definition(),
+ )
+ parent = cursor.semantic_parent
+ if parent is not None and parent.kind.name in fc.CLASS_KIND_NAMES:
+ class_qn = self.resolver.class_qn(parent)
+ if class_qn is not None:
+ self._add_edge(
+ cs.RelationshipType.DEFINES,
+ fc.LABEL_CLASS,
+ class_qn,
+ fc.LABEL_TYPE,
+ qn,
+ )
+ return
+ self._add_edge(
+ cs.RelationshipType.DEFINES, fc.LABEL_MODULE, module_qn, fc.LABEL_TYPE, qn
+ )
+
+ def _process_call(self, cursor: Cursor, enclosing: _Scope) -> None:
+ # (H) Resolve the callee semantically via cursor.referenced (libclang did
+ # (H) the overload/name resolution already), preferring its definition so
+ # (H) the edge targets the node the frontend emitted for the body.
+ if enclosing is None:
+ return
+ referenced = cursor.referenced
+ if referenced is None:
+ return
+ callee = referenced.get_definition() or referenced
+ callee_label = _classify(callee)
+ if callee_label is None or callee_label == fc.LABEL_CLASS:
+ return
+ callee_qn = (
+ self.resolver.method_qn(callee)
+ if callee_label == fc.LABEL_METHOD
+ else self.resolver.function_qn(callee)
+ )
+ if callee_qn is None:
+ return # (H) callee outside the indexed repo (stdlib, etc.)
+ caller_label, caller_qn = enclosing
+ self._add_edge(
+ cs.RelationshipType.CALLS, caller_label, caller_qn, callee_label, callee_qn
+ )
+
+ def _emit_inheritance(self, cursor: Cursor, derived_qn: str) -> None:
+ for child in cursor.get_children():
+ if child.kind.name != fc.KIND_BASE_SPECIFIER:
+ continue
+ base_decl = child.type.get_declaration()
+ base_qn = self.resolver.class_qn(base_decl) if base_decl else None
+ if base_qn is None:
+ base_qn = _base_simple_name(child.type.spelling)
+ self._add_edge(
+ cs.RelationshipType.INHERITS,
+ fc.LABEL_CLASS,
+ derived_qn,
+ fc.LABEL_CLASS,
+ base_qn,
+ )
+
+ def _contains_module_parent(self, rel: str) -> tuple[str, str, str]:
+ # (H) Mirror DefinitionProcessor's module-parent choice: a Package if the
+ # (H) directory is one, else a Folder, else the Project at the root.
+ parent_rel = Path(rel).parent
+ package_qn = (
+ self.structural_elements.get(parent_rel)
+ if self.structural_elements is not None
+ else None
+ )
+ if package_qn:
+ return (cs.NodeLabel.PACKAGE, cs.KEY_QUALIFIED_NAME, package_qn)
+ if parent_rel != Path(cs.SEPARATOR_DOT):
+ return (cs.NodeLabel.FOLDER, cs.KEY_PATH, parent_rel.as_posix())
+ return (cs.NodeLabel.PROJECT, cs.KEY_NAME, self.resolver.project_name)
+
+ def _register(self, label: str, props: PropertyDict) -> None:
+ if self.function_registry is None:
+ return
+ qn = props[cs.KEY_QUALIFIED_NAME]
+ if not isinstance(qn, str):
+ return
+ self.function_registry[qn] = NodeType(label)
+ name = props[cs.KEY_NAME]
+ if self.simple_name_lookup is not None and isinstance(name, str):
+ self.simple_name_lookup[name].add(qn)
+
+ def flush(self, ingestor: IngestorProtocol) -> None:
+ for module_qn, props in self.modules.items():
+ ingestor.ensure_node_batch(fc.LABEL_MODULE, props)
+ path = props[cs.KEY_PATH]
+ if self.structural_elements is not None and isinstance(path, str):
+ ingestor.ensure_relationship_batch(
+ self._contains_module_parent(path),
+ cs.RelationshipType.CONTAINS_MODULE,
+ (fc.LABEL_MODULE, cs.KEY_QUALIFIED_NAME, module_qn),
+ )
+ for label, props, _ in self.nodes.values():
+ ingestor.ensure_node_batch(label, props)
+ self._register(label, props)
+ for rel_type, from_label, from_qn, to_label, to_qn in self.edges:
+ ingestor.ensure_relationship_batch(
+ (from_label, cs.KEY_QUALIFIED_NAME, from_qn),
+ rel_type,
+ (to_label, cs.KEY_QUALIFIED_NAME, to_qn),
+ )
+
+
+def _walk(cursor: Cursor, collector: _Collector, enclosing: _Scope = None) -> None:
+ for child in cursor.get_children():
+ produced = collector.process(child, enclosing)
+ _walk(child, collector, produced or enclosing)
+
+
+def run_cpp_frontend(
+ ingestor: IngestorProtocol,
+ repo_path: Path,
+ project_name: str,
+ compdb_dir: Path,
+ function_registry: FunctionRegistryTrieProtocol | None = None,
+ simple_name_lookup: SimpleNameLookup | None = None,
+ structural_elements: dict[Path, str | None] | None = None,
+) -> frozenset[str]:
+ """Index C/C++ via libclang + a compile_commands.json (macro-accurate).
+
+ Parses every translation unit in the compilation database, walks the cursor
+ tree, and emits Module/Class/Function/Method nodes plus DEFINES /
+ DEFINES_METHOD / INHERITS edges and exact spans straight to the ingestor,
+ synthesizing the same qualified names the tree-sitter path would. Returns the
+ set of repo-relative files it covered (so callers can skip them in the
+ tree-sitter pass).
+
+ When ``function_registry`` / ``simple_name_lookup`` are supplied, emitted
+ definitions are registered for cross-file resolution; when
+ ``structural_elements`` is supplied, each Module is linked to its parent via
+ CONTAINS_MODULE (the full-replace path used by GraphUpdater).
+ """
+ import clang.cindex as ci
+
+ resolver = CppQnResolver(repo_path, project_name)
+ collector = _Collector(
+ resolver, function_registry, simple_name_lookup, structural_elements
+ )
+
+ db = ci.CompilationDatabase.fromDirectory(str(Path(compdb_dir).resolve()))
+ index = ci.Index.create()
+ for command in db.getAllCompileCommands():
+ args = list(command.arguments)[1:]
+ try:
+ tu = index.parse(None, args=args)
+ except ci.TranslationUnitLoadError:
+ continue
+ _walk(tu.cursor, collector)
+
+ collector.flush(ingestor)
+ return frozenset(collector.covered)
diff --git a/codebase_rag/parsers/cpp_frontend/qn.py b/codebase_rag/parsers/cpp_frontend/qn.py
new file mode 100644
index 000000000..b427aa232
--- /dev/null
+++ b/codebase_rag/parsers/cpp_frontend/qn.py
@@ -0,0 +1,171 @@
+from __future__ import annotations
+
+import os
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+from ... import constants as cs
+from ...utils.path_utils import should_skip_rel_file
+from ..cpp.utils import convert_operator_symbol_to_name
+from . import constants as fc
+
+if TYPE_CHECKING:
+ from clang.cindex import Cursor
+
+
+def _eligible_rel_files(repo_path: Path) -> list[str]:
+ # (H) Reproduce GraphUpdater._collect_eligible_files' ordering exactly: an
+ # (H) os.walk with dirnames AND filenames sorted, top-down. The module-qn
+ # (H) disambiguation below depends on this order (the file processed LATER in
+ # (H) a basename collision is the one that gets its extension appended), so it
+ # (H) must match cgr's tree-sitter pass to produce identical qualified names.
+ repo_str = str(repo_path)
+ repo_prefix_len = len(repo_str) + 1
+ rels: list[str] = []
+ for dirpath, dirnames, filenames in os.walk(repo_str):
+ rel_dir = "" if len(dirpath) < repo_prefix_len else dirpath[repo_prefix_len:]
+ rel_dir = rel_dir.replace(os.sep, "/")
+ dir_parts = tuple(rel_dir.split("/")) if rel_dir else ()
+ dir_prefix = f"{rel_dir}/" if rel_dir else ""
+ dirnames[:] = sorted(dirnames)
+ for fname in sorted(filenames):
+ dot = fname.rfind(".")
+ suffix = fname[dot:] if dot != -1 else ""
+ rel_path_str = f"{dir_prefix}{fname}"
+ if not should_skip_rel_file(rel_path_str, dir_parts, suffix):
+ rels.append(rel_path_str)
+ return rels
+
+
+def _base_module_qn(rel: str, project_name: str) -> str:
+ rel_path = Path(rel)
+ if rel_path.name in (cs.INIT_PY, cs.MOD_RS):
+ parts = rel_path.parent.parts
+ else:
+ parts = rel_path.with_suffix("").parts
+ return cs.SEPARATOR_DOT.join([project_name, *parts])
+
+
+def build_module_qn_map(repo_path: Path, project_name: str) -> dict[str, str]:
+ # (H) Mirror DefinitionProcessor._disambiguate_module_qn: a base qn is claimed
+ # (H) by the first file (in walk order); a later file colliding on that base qn
+ # (H) gets its extension appended (foo.cpp -> proj.foo, foo.h -> proj.foo.h).
+ claimed: dict[str, str] = {}
+ result: dict[str, str] = {}
+ for rel in _eligible_rel_files(repo_path):
+ base = _base_module_qn(rel, project_name)
+ existing = claimed.get(base)
+ if existing is None or existing == rel:
+ final = base
+ else:
+ suffix = Path(rel).suffix.lstrip(cs.SEPARATOR_DOT)
+ final = f"{base}{cs.SEPARATOR_DOT}{suffix}"
+ claimed.setdefault(final, rel)
+ result[rel] = final
+ return result
+
+
+class CppQnResolver:
+ """Synthesizes cgr-correct qualified names for libclang cursors.
+
+ The qns must be byte-identical to what the tree-sitter C++ path produces
+ (parsers/cpp/utils.build_qualified_name + the deferred out-of-class method
+ resolver), because the whole graph keys on them.
+ """
+
+ def __init__(self, repo_path: Path, project_name: str) -> None:
+ self.repo_path = repo_path.resolve()
+ self.project_name = project_name
+ self._module_qn = build_module_qn_map(self.repo_path, project_name)
+
+ def rel_path(self, absolute_file: str) -> str | None:
+ try:
+ return Path(absolute_file).resolve().relative_to(self.repo_path).as_posix()
+ except ValueError:
+ return None
+
+ def module_qn(self, absolute_file: str) -> str | None:
+ rel = self.rel_path(absolute_file)
+ if rel is None:
+ return None
+ return self._module_qn.get(rel)
+
+ def _namespace_chain(self, cursor: Cursor) -> list[str]:
+ parts: list[str] = []
+ parent = cursor.semantic_parent
+ while parent is not None and parent.kind.name == fc.KIND_NAMESPACE:
+ if parent.spelling: # (H) skip anonymous namespaces (no name segment)
+ parts.append(parent.spelling)
+ parent = parent.semantic_parent
+ parts.reverse()
+ return parts
+
+ def member_name(self, cursor: Cursor) -> str:
+ # (H) Mirror cpp.utils.extract_operator_name / extract_destructor_name:
+ # (H) destructors keep their `~Name` spelling, operators map their symbol
+ # (H) through CPP_OPERATOR_SYMBOL_MAP; everything else is its plain name.
+ spelling = cursor.spelling
+ if cursor.kind.name == fc.KIND_DESTRUCTOR:
+ return spelling
+ if self._is_operator_spelling(spelling):
+ symbol = spelling[len(cs.CPP_OPERATOR_TEXT_PREFIX) :].strip()
+ return convert_operator_symbol_to_name(symbol)
+ return spelling
+
+ @staticmethod
+ def _is_operator_spelling(spelling: str) -> bool:
+ prefix = cs.CPP_OPERATOR_TEXT_PREFIX
+ if not spelling.startswith(prefix):
+ return False
+ rest = spelling[len(prefix) :]
+ # (H) `operator+`, `operator[]`, `operator int` are operators/conversions;
+ # (H) an identifier like `operatorState` is not (next char is alnum/_).
+ return not rest or not (rest[0].isalnum() or rest[0] == cs.CHAR_UNDERSCORE)
+
+ def class_qn(self, cursor: Cursor) -> str | None:
+ if cursor.location.file is None:
+ return None
+ module_qn = self.module_qn(cursor.location.file.name)
+ if module_qn is None:
+ return None
+ parts = [module_qn, *self._namespace_chain(cursor), cursor.spelling]
+ return cs.SEPARATOR_DOT.join(parts)
+
+ def function_qn(self, cursor: Cursor) -> str | None:
+ if cursor.location.file is None:
+ return None
+ module_qn = self.module_qn(cursor.location.file.name)
+ if module_qn is None:
+ return None
+ parts = [module_qn, *self._namespace_chain(cursor), self.member_name(cursor)]
+ return cs.SEPARATOR_DOT.join(parts)
+
+ def type_qn(self, cursor: Cursor) -> str | None:
+ # (H) A class-scoped `using`/`typedef` is anchored to its enclosing class
+ # (H) (e.g. proj.Box.Handle); a namespace/file-scoped one mirrors a free
+ # (H) function's qn (module + namespace chain + name).
+ parent = cursor.semantic_parent
+ if parent is not None and parent.kind.name in fc.CLASS_KIND_NAMES:
+ class_qn = self.class_qn(parent)
+ if class_qn is None:
+ return None
+ return cs.SEPARATOR_DOT.join([class_qn, cursor.spelling])
+ if cursor.location.file is None:
+ return None
+ module_qn = self.module_qn(cursor.location.file.name)
+ if module_qn is None:
+ return None
+ parts = [module_qn, *self._namespace_chain(cursor), cursor.spelling]
+ return cs.SEPARATOR_DOT.join(parts)
+
+ def method_qn(self, cursor: Cursor) -> str | None:
+ # (H) A method's qn is anchored to its CLASS's declaring file (the header),
+ # (H) via semantic_parent, NOT the out-of-line definition file. This mirrors
+ # (H) cgr's deferred out-of-class method resolver.
+ parent = cursor.semantic_parent
+ if parent is None:
+ return None
+ class_qn = self.class_qn(parent)
+ if class_qn is None:
+ return None
+ return cs.SEPARATOR_DOT.join([class_qn, self.member_name(cursor)])
diff --git a/codebase_rag/parsers/definition_processor.py b/codebase_rag/parsers/definition_processor.py
index 8110140f8..a8331698e 100644
--- a/codebase_rag/parsers/definition_processor.py
+++ b/codebase_rag/parsers/definition_processor.py
@@ -4,16 +4,19 @@
from typing import TYPE_CHECKING
from loguru import logger
+from tree_sitter import QueryCursor
from .. import constants as cs
from .. import logs as ls
+from ..parser_loader import COMBINED_FUNC_CLASS_IMPORT_QUERIES
from ..types_defs import ASTNode, FunctionRegistryTrieProtocol, SimpleNameLookup
+from ..utils.path_utils import cached_relative_path, cached_resolve_posix
from .class_ingest import ClassIngestMixin
from .dependency_parser import parse_dependencies
from .function_ingest import FunctionIngestMixin
from .handlers import get_handler
from .js_ts.ingest import JsTsIngestMixin
-from .utils import safe_decode_with_fallback
+from .utils import safe_decode_with_fallback, sorted_captures
if TYPE_CHECKING:
from ..services import IngestorProtocol
@@ -38,6 +41,7 @@ def __init__(
simple_name_lookup: SimpleNameLookup,
import_processor: ImportProcessor,
module_qn_to_file_path: dict[str, Path],
+ func_class_captures_cache: dict[Path, dict] | None = None,
):
super().__init__()
self.ingestor = ingestor
@@ -48,7 +52,22 @@ def __init__(
self.import_processor = import_processor
self.module_qn_to_file_path = module_qn_to_file_path
self.class_inheritance: dict[str, list[str]] = {}
+ self._deferred_cpp_methods: list = []
+ self._deferred_go_methods: list = []
self._handler = get_handler(cs.SupportedLanguage.PYTHON)
+ self._func_class_captures_cache = func_class_captures_cache
+
+ def _disambiguate_module_qn(self, module_qn: str, file_path: Path) -> str:
+ # (H) Two files that share a basename but differ by extension (foo.py /
+ # (H) foo.cpp) strip to the same module qn. Append the extension to the
+ # (H) later one so their module nodes and all derived class/method qns stay
+ # (H) distinct instead of colliding under the qualified_name constraint.
+ existing = self.module_qn_to_file_path.get(module_qn)
+ if existing is None or existing == file_path:
+ return module_qn
+ return (
+ f"{module_qn}{cs.SEPARATOR_DOT}{file_path.suffix.lstrip(cs.SEPARATOR_DOT)}"
+ )
def process_file(
self,
@@ -56,10 +75,12 @@ def process_file(
language: cs.SupportedLanguage,
queries: dict[cs.SupportedLanguage, LanguageQueries],
structural_elements: dict[Path, str | None],
+ source_bytes: bytes | None = None,
+ pre_parsed: tuple[ASTNode, dict[str, list] | None] | None = None,
) -> tuple[ASTNode, cs.SupportedLanguage] | None:
if isinstance(file_path, str):
file_path = Path(file_path)
- relative_path = file_path.relative_to(self.repo_path)
+ relative_path = cached_relative_path(file_path, self.repo_path)
relative_path_str = str(relative_path)
logger.info(
ls.DEF_PARSING_AST.format(language=language, path=relative_path_str)
@@ -75,15 +96,19 @@ def process_file(
return None
self._handler = get_handler(language)
- source_bytes = file_path.read_bytes()
- lang_queries = queries[language]
- parser = lang_queries.get(cs.KEY_PARSER)
- if not parser:
- logger.warning(ls.DEF_NO_PARSER.format(language=language))
- return None
-
- tree = parser.parse(source_bytes)
- root_node = tree.root_node
+ if pre_parsed is not None:
+ root_node, pre_combined_captures = pre_parsed
+ else:
+ if source_bytes is None:
+ source_bytes = file_path.read_bytes()
+ lang_queries = queries[language]
+ parser = lang_queries.get(cs.KEY_PARSER)
+ if not parser:
+ logger.warning(ls.DEF_NO_PARSER.format(language=language))
+ return None
+ tree = parser.parse(source_bytes)
+ root_node = tree.root_node
+ pre_combined_captures = None
module_qn = cs.SEPARATOR_DOT.join(
[self.project_name] + list(relative_path.with_suffix("").parts)
@@ -92,6 +117,7 @@ def process_file(
module_qn = cs.SEPARATOR_DOT.join(
[self.project_name] + list(relative_path.parent.parts)
)
+ module_qn = self._disambiguate_module_qn(module_qn, file_path)
self.module_qn_to_file_path[module_qn] = file_path
self.ingestor.ensure_node_batch(
@@ -100,6 +126,7 @@ def process_file(
cs.KEY_QUALIFIED_NAME: module_qn,
cs.KEY_NAME: file_path.name,
cs.KEY_PATH: relative_path_str,
+ cs.KEY_ABSOLUTE_PATH: cached_resolve_posix(file_path),
},
)
@@ -120,22 +147,61 @@ def process_file(
(cs.NodeLabel.MODULE, cs.KEY_QUALIFIED_NAME, module_qn),
)
- self.import_processor.parse_imports(root_node, module_qn, language, queries)
- self._ingest_missing_import_patterns(
- root_node, module_qn, language, queries
+ if pre_combined_captures is not None:
+ combined_captures = pre_combined_captures
+ else:
+ combined_captures = None
+ combined_query = COMBINED_FUNC_CLASS_IMPORT_QUERIES.get(language)
+ if combined_query:
+ cursor = QueryCursor(combined_query)
+ combined_captures = sorted_captures(cursor, root_node)
+ if self._func_class_captures_cache is not None and combined_captures:
+ cache_entry: dict[str, list] = {}
+ for key in (cs.CAPTURE_FUNCTION, cs.CAPTURE_CLASS, cs.CAPTURE_CALL):
+ if key in combined_captures:
+ cache_entry[key] = combined_captures[key]
+ if cache_entry:
+ self._func_class_captures_cache[file_path] = cache_entry
+
+ self.import_processor.parse_imports(
+ root_node,
+ module_qn,
+ language,
+ queries,
+ pre_captures=combined_captures,
)
+ if language in (cs.SupportedLanguage.JS, cs.SupportedLanguage.TS):
+ self._ingest_missing_import_patterns(
+ root_node, module_qn, language, queries
+ )
if language == cs.SupportedLanguage.CPP:
self._ingest_cpp_module_declarations(root_node, module_qn, file_path)
- self._ingest_all_functions(root_node, module_qn, language, queries)
- self._ingest_classes_and_methods(root_node, module_qn, language, queries)
- self._ingest_object_literal_methods(root_node, module_qn, language, queries)
- self._ingest_commonjs_exports(root_node, module_qn, language, queries)
- if language in {cs.SupportedLanguage.JS, cs.SupportedLanguage.TS}:
- self._ingest_es6_exports(root_node, module_qn, language, queries)
- self._ingest_assignment_arrow_functions(
- root_node, module_qn, language, queries
+ self._ingest_all_functions(
+ root_node,
+ module_qn,
+ language,
+ queries,
+ combined_captures=combined_captures,
+ )
+ self._ingest_classes_and_methods(
+ root_node,
+ module_qn,
+ language,
+ queries,
+ combined_captures=combined_captures,
)
- self._ingest_prototype_inheritance(root_node, module_qn, language, queries)
+ if language in (cs.SupportedLanguage.JS, cs.SupportedLanguage.TS):
+ self._ingest_object_literal_methods(
+ root_node, module_qn, language, queries
+ )
+ self._ingest_commonjs_exports(root_node, module_qn, language, queries)
+ self._ingest_es6_exports(root_node, module_qn, language, queries)
+ self._ingest_assignment_arrow_functions(
+ root_node, module_qn, language, queries
+ )
+ self._ingest_prototype_inheritance(
+ root_node, module_qn, language, queries
+ )
return (root_node, language)
diff --git a/codebase_rag/parsers/dependency_parser.py b/codebase_rag/parsers/dependency_parser.py
index 61f7d4b92..94a66ad87 100644
--- a/codebase_rag/parsers/dependency_parser.py
+++ b/codebase_rag/parsers/dependency_parser.py
@@ -26,11 +26,15 @@ def _extract_pep508_package_name(dep_string: str) -> tuple[str, str]:
class DependencyParser:
+ __slots__ = ()
+
def parse(self, file_path: Path) -> list[Dependency]:
raise NotImplementedError
class PyProjectTomlParser(DependencyParser):
+ __slots__ = ()
+
def parse(self, file_path: Path) -> list[Dependency]:
dependencies: list[Dependency] = []
try:
@@ -72,6 +76,8 @@ def parse(self, file_path: Path) -> list[Dependency]:
class RequirementsTxtParser(DependencyParser):
+ __slots__ = ()
+
def parse(self, file_path: Path) -> list[Dependency]:
dependencies: list[Dependency] = []
try:
@@ -92,6 +98,8 @@ def parse(self, file_path: Path) -> list[Dependency]:
class PackageJsonParser(DependencyParser):
+ __slots__ = ()
+
def parse(self, file_path: Path) -> list[Dependency]:
dependencies: list[Dependency] = []
try:
@@ -120,6 +128,8 @@ def _load_and_collect_deps(
class CargoTomlParser(DependencyParser):
+ __slots__ = ()
+
def parse(self, file_path: Path) -> list[Dependency]:
dependencies: list[Dependency] = []
try:
@@ -148,6 +158,8 @@ def parse(self, file_path: Path) -> list[Dependency]:
class GoModParser(DependencyParser):
+ __slots__ = ()
+
def parse(self, file_path: Path) -> list[Dependency]:
dependencies: list[Dependency] = []
try:
@@ -186,6 +198,8 @@ def parse(self, file_path: Path) -> list[Dependency]:
class GemfileParser(DependencyParser):
+ __slots__ = ()
+
def parse(self, file_path: Path) -> list[Dependency]:
dependencies: list[Dependency] = []
try:
@@ -206,6 +220,8 @@ def parse(self, file_path: Path) -> list[Dependency]:
class ComposerJsonParser(DependencyParser):
+ __slots__ = ()
+
def parse(self, file_path: Path) -> list[Dependency]:
dependencies: list[Dependency] = []
try:
@@ -229,6 +245,8 @@ def parse(self, file_path: Path) -> list[Dependency]:
class CsprojParser(DependencyParser):
+ __slots__ = ()
+
def parse(self, file_path: Path) -> list[Dependency]:
dependencies: list[Dependency] = []
try:
diff --git a/codebase_rag/parsers/factory.py b/codebase_rag/parsers/factory.py
index a6b8a244c..cdc5206f0 100644
--- a/codebase_rag/parsers/factory.py
+++ b/codebase_rag/parsers/factory.py
@@ -16,6 +16,25 @@
class ProcessorFactory:
+ __slots__ = (
+ "ingestor",
+ "repo_path",
+ "project_name",
+ "queries",
+ "function_registry",
+ "simple_name_lookup",
+ "ast_cache",
+ "unignore_paths",
+ "exclude_paths",
+ "module_qn_to_file_path",
+ "_import_processor",
+ "_structure_processor",
+ "_definition_processor",
+ "_type_inference",
+ "_call_processor",
+ "_func_class_captures_cache",
+ )
+
def __init__(
self,
ingestor: IngestorProtocol,
@@ -39,6 +58,7 @@ def __init__(
self.exclude_paths = exclude_paths
self.module_qn_to_file_path: dict[str, Path] = {}
+ self._func_class_captures_cache: dict[Path, dict] = {}
self._import_processor: ImportProcessor | None = None
self._structure_processor: StructureProcessor | None = None
@@ -81,6 +101,7 @@ def definition_processor(self) -> DefinitionProcessor:
simple_name_lookup=self.simple_name_lookup,
import_processor=self.import_processor,
module_qn_to_file_path=self.module_qn_to_file_path,
+ func_class_captures_cache=self._func_class_captures_cache,
)
return self._definition_processor
diff --git a/codebase_rag/parsers/function_ingest.py b/codebase_rag/parsers/function_ingest.py
index 1d32186e0..d87240c63 100644
--- a/codebase_rag/parsers/function_ingest.py
+++ b/codebase_rag/parsers/function_ingest.py
@@ -17,11 +17,13 @@
PropertyDict,
SimpleNameLookup,
)
-from ..utils.fqn_resolver import resolve_fqn_from_ast
+from ..utils.path_utils import cached_relative_path, cached_resolve_posix
from .cpp import utils as cpp_utils
+from .go import utils as go_utils
from .lua import utils as lua_utils
from .rs import utils as rs_utils
from .utils import (
+ callable_parameter_indices,
get_function_captures,
ingest_method,
is_method_node,
@@ -40,7 +42,32 @@ class FunctionResolution(NamedTuple):
is_exported: bool
+class _DeferredMethod(NamedTuple):
+ """Out-of-class C++ method whose class hasn't been parsed yet."""
+
+ method_name: str
+ class_name: str
+ fallback_class_qn: str
+ method_props: PropertyDict
+
+
+class _DeferredGoMethod(NamedTuple):
+ """Go receiver method, linked to its receiver type once all types are known."""
+
+ method_node: Node
+ module_qn: str
+ receiver_type: str
+ file_path: Path | None
+
+
+# (H) Go node labels a receiver type can resolve to (struct -> Class, defined
+# (H) type/alias -> Type, interface -> Interface); used to pick the declaring
+# (H) type out of same-named candidates when binding a cross-file method.
+_GO_TYPE_NODE_TYPES = frozenset({NodeType.CLASS, NodeType.TYPE, NodeType.INTERFACE})
+
+
class FunctionIngestMixin:
+ __slots__ = ()
ingestor: IngestorProtocol
repo_path: Path
project_name: str
@@ -48,6 +75,8 @@ class FunctionIngestMixin:
simple_name_lookup: SimpleNameLookup
module_qn_to_file_path: dict[str, Path]
_handler: LanguageHandler
+ _deferred_cpp_methods: list[_DeferredMethod]
+ _deferred_go_methods: list[_DeferredGoMethod]
@abstractmethod
def _get_docstring(self, node: ASTNode) -> str | None: ...
@@ -61,29 +90,33 @@ def _ingest_all_functions(
module_qn: str,
language: cs.SupportedLanguage,
queries: dict[cs.SupportedLanguage, LanguageQueries],
+ combined_captures: dict[str, list] | None = None,
) -> None:
- result = get_function_captures(root_node, language, queries)
- if not result:
- return
-
- lang_config, captures = result
+ if combined_captures is not None:
+ lang_queries = queries[language]
+ lang_config: LanguageSpec = lang_queries[cs.QUERY_CONFIG]
+ captures = combined_captures
+ else:
+ result = get_function_captures(root_node, language, queries)
+ if not result:
+ return
+ lang_config, captures = result
file_path = self.module_qn_to_file_path.get(module_qn)
+ has_classes = bool(captures.get(cs.CAPTURE_CLASS))
for func_node in captures.get(cs.CAPTURE_FUNCTION, []):
- if not isinstance(func_node, Node):
- logger.warning(
- ls.FUNC_EXPECTED_NODE.format(
- actual_type=type(func_node), value=func_node
- )
- )
- continue
- if self._is_method(func_node, lang_config):
+ if has_classes and self._is_method(func_node, lang_config):
continue
if language == cs.SupportedLanguage.CPP:
if self._handle_cpp_out_of_class_method(func_node, module_qn):
continue
+ if language == cs.SupportedLanguage.GO and self._defer_go_receiver_method(
+ func_node, module_qn
+ ):
+ continue
+
resolution = self._resolve_function_identity(
func_node, module_qn, language, lang_config, file_path
)
@@ -102,7 +135,9 @@ def _resolve_function_identity(
lang_config: LanguageSpec,
file_path: Path | None,
) -> FunctionResolution | None:
- resolution = self._try_unified_fqn_resolution(func_node, language, file_path)
+ resolution = self._try_unified_fqn_resolution(
+ func_node, module_qn, language, file_path
+ )
if resolution:
return resolution
@@ -113,6 +148,7 @@ def _resolve_function_identity(
def _try_unified_fqn_resolution(
self,
func_node: Node,
+ module_qn: str,
language: cs.SupportedLanguage,
file_path: Path | None,
) -> FunctionResolution | None:
@@ -120,19 +156,31 @@ def _try_unified_fqn_resolution(
if not fqn_config or not file_path:
return None
- func_qn = resolve_fqn_from_ast(
- func_node, file_path, self.repo_path, self.project_name, fqn_config
- )
- if not func_qn:
+ func_name = fqn_config.get_name(func_node)
+ if not func_name:
return None
- func_name = func_qn.split(cs.SEPARATOR_DOT)[-1]
+ parts = [func_name]
+ current = func_node.parent
+ while current:
+ if current.type in fqn_config.scope_node_types:
+ if scope_name := fqn_config.get_name(current):
+ parts.append(scope_name)
+ current = current.parent
+ parts.reverse()
+
+ # (H) Prefix with the module's resolved (collision-disambiguated) qn rather
+ # (H) than recomputing from the path, so same-stem cross-language siblings
+ # (H) stay distinct.
+ func_qn = module_qn + cs.SEPARATOR_DOT + cs.SEPARATOR_DOT.join(parts)
+ simple_name = func_qn.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+
is_exported = (
cpp_utils.is_exported(func_node)
if language == cs.SupportedLanguage.CPP
else False
)
- return FunctionResolution(func_qn, func_name, is_exported)
+ return FunctionResolution(func_qn, simple_name, is_exported)
def _fallback_function_resolution(
self,
@@ -147,6 +195,45 @@ def _fallback_function_resolution(
func_node, module_qn, language, lang_config
)
+ def _resolve_cpp_class_qn(
+ self, class_name: str, module_qn: str
+ ) -> tuple[str, bool]:
+ """Look up an existing Class node for *class_name* across all parsed files.
+
+ Returns ``(class_qn, resolved)`` where *resolved* is True when the
+ qualified name was obtained from the function registry (i.e. the
+ class has already been parsed, typically from a header file).
+ """
+ class_name_normalized = class_name.replace(
+ cs.SEPARATOR_DOUBLE_COLON, cs.SEPARATOR_DOT
+ )
+ leaf_name = class_name_normalized.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+
+ if leaf_name in self.simple_name_lookup:
+ for candidate_qn in self.simple_name_lookup[leaf_name]:
+ node_type = self.function_registry.get(candidate_qn)
+ if node_type in {NodeType.CLASS, NodeType.TYPE}:
+ if candidate_qn.endswith(
+ f".{class_name_normalized}"
+ ) and self._is_cpp_defined(candidate_qn):
+ return candidate_qn, True
+
+ return f"{module_qn}.{class_name_normalized}", False
+
+ def _is_cpp_defined(self, qn: str) -> bool:
+ # (H) A C++ out-of-class method may only bind to a class defined in a
+ # (H) C/C++ source file; matching a same-named class in another language
+ # (H) would collide their qualified names. Resolve qn -> defining file by
+ # (H) the longest module-qn prefix and check its extension.
+ parts = qn.split(cs.SEPARATOR_DOT)
+ while parts:
+ if path := self.module_qn_to_file_path.get(cs.SEPARATOR_DOT.join(parts)):
+ return (
+ path.suffix in cs.CPP_EXTENSIONS or path.suffix in cs.C_EXTENSIONS
+ )
+ parts = parts[:-1]
+ return False
+
def _handle_cpp_out_of_class_method(self, func_node: Node, module_qn: str) -> bool:
if not cpp_utils.is_out_of_class_method_definition(func_node):
return False
@@ -155,25 +242,163 @@ def _handle_cpp_out_of_class_method(self, func_node: Node, module_qn: str) -> bo
if not class_name:
return False
- class_name_normalized = class_name.replace(
- cs.SEPARATOR_DOUBLE_COLON, cs.SEPARATOR_DOT
- )
- class_qn = f"{module_qn}.{class_name_normalized}"
-
- ingest_method(
- method_node=func_node,
- container_qn=class_qn,
- container_type=cs.NodeLabel.CLASS,
- ingestor=self.ingestor,
- function_registry=self.function_registry,
- simple_name_lookup=self.simple_name_lookup,
- get_docstring_func=self._get_docstring,
- language=cs.SupportedLanguage.CPP,
- extract_decorators_func=self._extract_decorators,
- )
+ class_qn, resolved = self._resolve_cpp_class_qn(class_name, module_qn)
+ file_path = self.module_qn_to_file_path.get(module_qn)
+
+ if resolved:
+ ingest_method(
+ method_node=func_node,
+ container_qn=class_qn,
+ container_type=cs.NodeLabel.CLASS,
+ ingestor=self.ingestor,
+ function_registry=self.function_registry,
+ simple_name_lookup=self.simple_name_lookup,
+ get_docstring_func=self._get_docstring,
+ language=cs.SupportedLanguage.CPP,
+ extract_decorators_func=self._extract_decorators,
+ file_path=file_path,
+ repo_path=self.repo_path,
+ )
+ else:
+ method_name = cpp_utils.extract_function_name(func_node)
+ if not method_name:
+ return True
+ decorators = self._extract_decorators(func_node)
+ props: PropertyDict = {
+ cs.KEY_NAME: method_name,
+ cs.KEY_DECORATORS: decorators,
+ cs.KEY_START_LINE: func_node.start_point[0] + 1,
+ cs.KEY_END_LINE: func_node.end_point[0] + 1,
+ cs.KEY_DOCSTRING: self._get_docstring(func_node),
+ }
+ if file_path is not None and self.repo_path is not None:
+ props[cs.KEY_PATH] = cached_relative_path(
+ file_path, self.repo_path
+ ).as_posix()
+ props[cs.KEY_ABSOLUTE_PATH] = cached_resolve_posix(file_path)
+ if not hasattr(self, "_deferred_cpp_methods"):
+ self._deferred_cpp_methods = []
+ self._deferred_cpp_methods.append(
+ _DeferredMethod(
+ method_name=method_name,
+ class_name=class_name,
+ fallback_class_qn=class_qn,
+ method_props=props,
+ )
+ )
return True
+ def resolve_deferred_cpp_methods(self) -> int:
+ """Ingest deferred out-of-class C++ methods now that all classes are known.
+
+ Called after all files have been parsed so that every Class node
+ is guaranteed to be in the registry. Returns the number of
+ methods that were ingested.
+ """
+ deferred = getattr(self, "_deferred_cpp_methods", None)
+ if not deferred:
+ return 0
+
+ ingested = 0
+ for entry in deferred:
+ real_class_qn, resolved = self._resolve_cpp_class_qn(entry.class_name, "")
+ class_qn = real_class_qn if resolved else entry.fallback_class_qn
+ method_qn = f"{class_qn}.{entry.method_name}"
+
+ props = dict(entry.method_props)
+ props[cs.KEY_QUALIFIED_NAME] = method_qn
+
+ logger.info(ls.METHOD_FOUND.format(name=entry.method_name, qn=method_qn))
+ self.ingestor.ensure_node_batch(cs.NodeLabel.METHOD, props)
+ self.function_registry[method_qn] = NodeType.METHOD
+ self.simple_name_lookup[entry.method_name].add(method_qn)
+
+ self.ingestor.ensure_relationship_batch(
+ (cs.NodeLabel.CLASS, cs.KEY_QUALIFIED_NAME, class_qn),
+ cs.RelationshipType.DEFINES_METHOD,
+ (cs.NodeLabel.METHOD, cs.KEY_QUALIFIED_NAME, method_qn),
+ )
+ ingested += 1
+
+ self._deferred_cpp_methods = []
+ return ingested
+
+ def _defer_go_receiver_method(self, func_node: Node, module_qn: str) -> bool:
+ if not go_utils.is_receiver_method(func_node):
+ return False
+ receiver_type = go_utils.extract_receiver_type_name(func_node)
+ if not receiver_type:
+ return False
+ if not hasattr(self, "_deferred_go_methods"):
+ self._deferred_go_methods = []
+ self._deferred_go_methods.append(
+ _DeferredGoMethod(
+ method_node=func_node,
+ module_qn=module_qn,
+ receiver_type=receiver_type,
+ file_path=self.module_qn_to_file_path.get(module_qn),
+ )
+ )
+ return True
+
+ def _resolve_go_container_qn(self, module_qn: str, receiver_type: str) -> str:
+ # (H) A method binds to its receiver type. Prefer the same-file type, but
+ # (H) a Go package spans every file in its directory, so fall back to a
+ # (H) sibling-file type with the same name in the same package. This keeps
+ # (H) the method's qn and DEFINES_METHOD parent anchored to the real type
+ # (H) node instead of a phantom under the method's own module.
+ same_file = f"{module_qn}{cs.SEPARATOR_DOT}{receiver_type}"
+ if self.function_registry.get(same_file) is not None:
+ return same_file
+ package = module_qn.rsplit(cs.SEPARATOR_DOT, 1)[0]
+ for qn in self.simple_name_lookup.get(receiver_type, set()):
+ if self.function_registry.get(qn) not in _GO_TYPE_NODE_TYPES:
+ continue
+ type_module = qn.rsplit(cs.SEPARATOR_DOT, 1)[0]
+ if type_module.rsplit(cs.SEPARATOR_DOT, 1)[0] == package:
+ return qn
+ return same_file
+
+ def resolve_deferred_go_methods(self) -> int:
+ """Ingest Go receiver methods now that every receiver type is registered.
+
+ A Go method (``func (p Point) Area()``) is declared at file scope, not
+ inside its receiver type, so the receiver's node may not exist yet when
+ the method is first seen. Deferring to after Pass 2 lets the method bind
+ to the actual node label (``Class`` for structs, ``Type`` for defined
+ types, ``Interface`` for interfaces). Returns the number ingested.
+ """
+ deferred = getattr(self, "_deferred_go_methods", None)
+ if not deferred:
+ return 0
+
+ for entry in deferred:
+ container_qn = self._resolve_go_container_qn(
+ entry.module_qn, entry.receiver_type
+ )
+ container_type = self.function_registry.get(container_qn)
+ container_label = (
+ cs.NodeLabel(container_type.value)
+ if container_type is not None
+ else cs.NodeLabel.CLASS
+ )
+ ingest_method(
+ method_node=entry.method_node,
+ container_qn=container_qn,
+ container_type=container_label,
+ ingestor=self.ingestor,
+ function_registry=self.function_registry,
+ simple_name_lookup=self.simple_name_lookup,
+ get_docstring_func=self._get_docstring,
+ language=cs.SupportedLanguage.GO,
+ file_path=entry.file_path,
+ repo_path=self.repo_path,
+ )
+ ingested = len(deferred)
+ self._deferred_go_methods = []
+ return ingested
+
def _resolve_cpp_function(
self, func_node: Node, module_qn: str
) -> FunctionResolution | None:
@@ -238,13 +463,23 @@ def _register_function(
language: cs.SupportedLanguage,
lang_config: LanguageSpec,
) -> None:
- func_props = self._build_function_props(func_node, resolution)
+ unique_qn = self.function_registry.register_unique_qn(
+ resolution.qualified_name, func_node.start_point[0] + 1
+ )
+ if unique_qn != resolution.qualified_name:
+ resolution = resolution._replace(qualified_name=unique_qn)
+
+ func_props = self._build_function_props(func_node, resolution, module_qn)
logger.info(
ls.FUNC_FOUND.format(name=resolution.name, qn=resolution.qualified_name)
)
self.ingestor.ensure_node_batch(cs.NodeLabel.FUNCTION, func_props)
self.function_registry[resolution.qualified_name] = NodeType.FUNCTION
+ self.function_registry.mark_callable_params(
+ resolution.qualified_name,
+ callable_parameter_indices(func_node, language),
+ )
if resolution.name:
self.simple_name_lookup[resolution.name].add(resolution.qualified_name)
@@ -253,9 +488,10 @@ def _register_function(
)
def _build_function_props(
- self, func_node: Node, resolution: FunctionResolution
+ self, func_node: Node, resolution: FunctionResolution, module_qn: str
) -> PropertyDict:
- return {
+ file_path = self.module_qn_to_file_path.get(module_qn)
+ props: PropertyDict = {
cs.KEY_QUALIFIED_NAME: resolution.qualified_name,
cs.KEY_NAME: resolution.name,
cs.KEY_DECORATORS: self._extract_decorators(func_node),
@@ -264,6 +500,12 @@ def _build_function_props(
cs.KEY_DOCSTRING: self._get_docstring(func_node),
cs.KEY_IS_EXPORTED: resolution.is_exported,
}
+ if file_path is not None:
+ props[cs.KEY_PATH] = cached_relative_path(
+ file_path, self.repo_path
+ ).as_posix()
+ props[cs.KEY_ABSOLUTE_PATH] = cached_resolve_posix(file_path)
+ return props
def _create_function_relationships(
self,
@@ -274,7 +516,7 @@ def _create_function_relationships(
lang_config: LanguageSpec,
) -> None:
parent_type, parent_qn = self._determine_function_parent(
- func_node, module_qn, lang_config
+ func_node, resolution.qualified_name, module_qn, lang_config, language
)
self.ingestor.ensure_relationship_batch(
(parent_type, cs.KEY_QUALIFIED_NAME, parent_qn),
@@ -444,25 +686,55 @@ def _is_method(self, func_node: Node, lang_config: LanguageSpec) -> bool:
return is_method_node(func_node, lang_config)
def _determine_function_parent(
- self, func_node: Node, module_qn: str, lang_config: LanguageSpec
+ self,
+ func_node: Node,
+ func_qn: str,
+ module_qn: str,
+ lang_config: LanguageSpec,
+ language: cs.SupportedLanguage | None = None,
) -> tuple[str, str]:
current = func_node.parent
if not isinstance(current, Node):
return cs.NodeLabel.MODULE, module_qn
+ file_path = self.module_qn_to_file_path.get(module_qn)
while current and current.type not in lang_config.module_node_types:
if current.type in lang_config.function_node_types:
- if name_node := current.child_by_field_name(cs.FIELD_NAME):
- parent_text = name_node.text
- if parent_text is None:
- continue
- if parent_func_name := safe_decode_text(name_node):
- if parent_func_qn := self._build_nested_qualified_name(
- current, module_qn, parent_func_name, lang_config
- ):
- return cs.NodeLabel.FUNCTION, parent_func_qn
- break
+ parent_label = (
+ cs.NodeLabel.METHOD
+ if self._is_method(current, lang_config)
+ else cs.NodeLabel.FUNCTION
+ )
+ # (H) Bind to the enclosing function's OWN qn, recomputed from its
+ # (H) node. A function nested in an anonymous callback otherwise
+ # (H) loses that callback: anonymous scopes contribute no segment to
+ # (H) the child qn, so trimming the child qn would skip the callback
+ # (H) and hoist the child to the nearest named ancestor.
+ resolution = (
+ self._resolve_function_identity(
+ current, module_qn, language, lang_config, file_path
+ )
+ if language is not None
+ else None
+ )
+ parent_qn = (
+ resolution.qualified_name
+ if resolution
+ else func_qn.rsplit(cs.SEPARATOR_DOT, 1)[0]
+ )
+ if not parent_qn or parent_qn == func_qn:
+ break
+ return parent_label, parent_qn
current = current.parent
+ # (H) A Rust item inside `mod inner` is contained by that inline module,
+ # (H) not the file module. Its enclosing module qn is the file module plus
+ # (H) the mod path; the inline Module node carries that exact qn.
+ if language == cs.SupportedLanguage.RUST and (
+ mod_parts := rs_utils.build_module_path(func_node)
+ ):
+ nested = module_qn + cs.SEPARATOR_DOT + cs.SEPARATOR_DOT.join(mod_parts)
+ return cs.NodeLabel.MODULE, nested
+
return cs.NodeLabel.MODULE, module_qn
diff --git a/codebase_rag/parsers/go/__init__.py b/codebase_rag/parsers/go/__init__.py
new file mode 100644
index 000000000..78ac91463
--- /dev/null
+++ b/codebase_rag/parsers/go/__init__.py
@@ -0,0 +1,6 @@
+from .utils import extract_receiver_type_name, is_receiver_method
+
+__all__ = [
+ "extract_receiver_type_name",
+ "is_receiver_method",
+]
diff --git a/codebase_rag/parsers/go/utils.py b/codebase_rag/parsers/go/utils.py
new file mode 100644
index 000000000..c4f0813c0
--- /dev/null
+++ b/codebase_rag/parsers/go/utils.py
@@ -0,0 +1,36 @@
+from __future__ import annotations
+
+from tree_sitter import Node
+
+from ... import constants as cs
+from ..utils import safe_decode_text
+
+
+def is_receiver_method(node: Node) -> bool:
+ return (
+ node.type == cs.TS_GO_METHOD_DECLARATION
+ and node.child_by_field_name(cs.FIELD_RECEIVER) is not None
+ )
+
+
+def extract_receiver_type_name(node: Node) -> str | None:
+ receiver = node.child_by_field_name(cs.FIELD_RECEIVER)
+ if receiver is None:
+ return None
+ for param in receiver.children:
+ if param.type != cs.TS_GO_PARAMETER_DECLARATION:
+ continue
+ type_node = param.child_by_field_name(cs.FIELD_TYPE)
+ if type_node is not None:
+ return _type_identifier_text(type_node)
+ return None
+
+
+def _type_identifier_text(type_node: Node) -> str | None:
+ if type_node.type == cs.TS_TYPE_IDENTIFIER and type_node.text:
+ return safe_decode_text(type_node)
+ # (H) Unwrap pointer (*T) and generic (T[P]) receivers down to the base name.
+ for child in type_node.children:
+ if name := _type_identifier_text(child):
+ return name
+ return None
diff --git a/codebase_rag/parsers/handlers/base.py b/codebase_rag/parsers/handlers/base.py
index 14fa8cec9..7f264c1e1 100644
--- a/codebase_rag/parsers/handlers/base.py
+++ b/codebase_rag/parsers/handlers/base.py
@@ -13,6 +13,8 @@
class BaseLanguageHandler:
+ __slots__ = ()
+
def is_inside_method_with_object_literals(self, node: ASTNode) -> bool:
return False
diff --git a/codebase_rag/parsers/handlers/cpp.py b/codebase_rag/parsers/handlers/cpp.py
index d7c9dea04..854bcc4ac 100644
--- a/codebase_rag/parsers/handlers/cpp.py
+++ b/codebase_rag/parsers/handlers/cpp.py
@@ -17,6 +17,8 @@
class CppHandler(BaseLanguageHandler):
+ __slots__ = ()
+
def extract_function_name(self, node: ASTNode) -> str | None:
if func_name := cpp_utils.extract_function_name(node):
return func_name
diff --git a/codebase_rag/parsers/handlers/java.py b/codebase_rag/parsers/handlers/java.py
index 4bd576beb..882fae0da 100644
--- a/codebase_rag/parsers/handlers/java.py
+++ b/codebase_rag/parsers/handlers/java.py
@@ -11,6 +11,8 @@
class JavaHandler(BaseLanguageHandler):
+ __slots__ = ()
+
def extract_decorators(self, node: ASTNode) -> list[str]:
return java_utils.extract_from_modifiers_node(node, frozenset()).annotations
diff --git a/codebase_rag/parsers/handlers/js_ts.py b/codebase_rag/parsers/handlers/js_ts.py
index 7a2ed6684..75c561209 100644
--- a/codebase_rag/parsers/handlers/js_ts.py
+++ b/codebase_rag/parsers/handlers/js_ts.py
@@ -12,6 +12,8 @@
class JsTsHandler(BaseLanguageHandler):
+ __slots__ = ()
+
def extract_decorators(self, node: ASTNode) -> list[str]:
return [
decorator_text
diff --git a/codebase_rag/parsers/handlers/lua.py b/codebase_rag/parsers/handlers/lua.py
index 9db185904..6b2d6177f 100644
--- a/codebase_rag/parsers/handlers/lua.py
+++ b/codebase_rag/parsers/handlers/lua.py
@@ -11,6 +11,8 @@
class LuaHandler(BaseLanguageHandler):
+ __slots__ = ()
+
def extract_function_name(self, node: ASTNode) -> str | None:
if (name_node := node.child_by_field_name(cs.TS_FIELD_NAME)) and name_node.text:
from ..utils import safe_decode_text
diff --git a/codebase_rag/parsers/handlers/php.py b/codebase_rag/parsers/handlers/php.py
new file mode 100644
index 000000000..e529ab7dd
--- /dev/null
+++ b/codebase_rag/parsers/handlers/php.py
@@ -0,0 +1,62 @@
+from __future__ import annotations
+
+from typing import TYPE_CHECKING
+
+from ... import constants as cs
+from ..utils import safe_decode_text
+from .base import BaseLanguageHandler
+
+if TYPE_CHECKING:
+ from ...types_defs import ASTNode
+
+
+class PhpHandler(BaseLanguageHandler):
+ __slots__ = ()
+
+ _CLASS_LIKE_TYPES = frozenset(
+ {
+ cs.TS_CLASS_DECLARATION,
+ cs.TS_INTERFACE_DECLARATION,
+ cs.TS_PHP_TRAIT_DECLARATION,
+ cs.TS_ENUM_DECLARATION,
+ }
+ )
+
+ def is_class_method(self, node: ASTNode) -> bool:
+ parent = node.parent
+ while parent:
+ if parent.type in self._CLASS_LIKE_TYPES:
+ return True
+ parent = parent.parent
+ return False
+
+ def extract_function_name(self, node: ASTNode) -> str | None:
+ if node.type == cs.TS_PHP_ANONYMOUS_FUNCTION:
+ return f"anonymous_{node.start_point[0]}_{node.start_point[1]}"
+ if node.type == cs.TS_PHP_ARROW_FUNCTION:
+ return f"arrow_{node.start_point[0]}_{node.start_point[1]}"
+ name_node = node.child_by_field_name(cs.TS_FIELD_NAME)
+ if name_node and name_node.text:
+ return safe_decode_text(name_node)
+ return None
+
+ def is_function_exported(self, node: ASTNode) -> bool:
+ if node.type != cs.TS_PHP_METHOD_DECLARATION:
+ return True
+ for child in node.children:
+ if child.type == cs.TS_PHP_VISIBILITY_MODIFIER:
+ text = safe_decode_text(child)
+ return text == "public"
+ return True
+
+ def extract_decorators(self, node: ASTNode) -> list[str]:
+ decorators: list[str] = []
+ for child in node.children:
+ if child.type == cs.TS_PHP_ATTRIBUTE_LIST:
+ for group in child.children:
+ if group.type == cs.TS_PHP_ATTRIBUTE_GROUP:
+ for attr in group.children:
+ if attr.type == cs.TS_PHP_ATTRIBUTE:
+ if text := safe_decode_text(attr):
+ decorators.append(text)
+ return decorators
diff --git a/codebase_rag/parsers/handlers/protocol.py b/codebase_rag/parsers/handlers/protocol.py
index 9bdbe72b6..893888d78 100644
--- a/codebase_rag/parsers/handlers/protocol.py
+++ b/codebase_rag/parsers/handlers/protocol.py
@@ -10,6 +10,8 @@
class LanguageHandler(Protocol):
+ __slots__ = ()
+
def is_inside_method_with_object_literals(self, node: ASTNode) -> bool: ...
def is_class_method(self, node: ASTNode) -> bool: ...
diff --git a/codebase_rag/parsers/handlers/python.py b/codebase_rag/parsers/handlers/python.py
index ae96501a5..1c424fdd8 100644
--- a/codebase_rag/parsers/handlers/python.py
+++ b/codebase_rag/parsers/handlers/python.py
@@ -11,6 +11,8 @@
class PythonHandler(BaseLanguageHandler):
+ __slots__ = ()
+
def extract_decorators(self, node: ASTNode) -> list[str]:
if not node.parent or node.parent.type != cs.TS_PY_DECORATED_DEFINITION:
return []
diff --git a/codebase_rag/parsers/handlers/registry.py b/codebase_rag/parsers/handlers/registry.py
index a886d7f9e..6f490700e 100644
--- a/codebase_rag/parsers/handlers/registry.py
+++ b/codebase_rag/parsers/handlers/registry.py
@@ -8,6 +8,7 @@
from .java import JavaHandler
from .js_ts import JsTsHandler
from .lua import LuaHandler
+from .php import PhpHandler
from .protocol import LanguageHandler
from .python import PythonHandler
from .rust import RustHandler
@@ -20,6 +21,7 @@
SupportedLanguage.RUST: RustHandler,
SupportedLanguage.JAVA: JavaHandler,
SupportedLanguage.LUA: LuaHandler,
+ SupportedLanguage.PHP: PhpHandler,
}
_DEFAULT_HANDLER = BaseLanguageHandler
diff --git a/codebase_rag/parsers/handlers/rust.py b/codebase_rag/parsers/handlers/rust.py
index 650bec974..186704ab2 100644
--- a/codebase_rag/parsers/handlers/rust.py
+++ b/codebase_rag/parsers/handlers/rust.py
@@ -17,6 +17,8 @@
class RustHandler(BaseLanguageHandler):
+ __slots__ = ()
+
def extract_decorators(self, node: ASTNode) -> list[str]:
outer_decorators: list[str] = []
sibling = node.prev_named_sibling
@@ -31,13 +33,12 @@ def extract_decorators(self, node: ASTNode) -> list[str]:
if body_node := node.child_by_field_name(cs.FIELD_BODY):
nodes_to_search.append(body_node)
+ inner_attr_type = cs.TS_RS_INNER_ATTRIBUTE_ITEM
for search_node in nodes_to_search:
- decorators.extend(
- attr_text
- for child in search_node.children
- if child.type == cs.TS_RS_INNER_ATTRIBUTE_ITEM
- if (attr_text := safe_decode_text(child))
- )
+ for child in search_node.children:
+ if child.type == inner_attr_type:
+ if attr_text := safe_decode_text(child):
+ decorators.append(attr_text)
return decorators
diff --git a/codebase_rag/parsers/import_processor.py b/codebase_rag/parsers/import_processor.py
index 99c3a8526..28f04cac3 100644
--- a/codebase_rag/parsers/import_processor.py
+++ b/codebase_rag/parsers/import_processor.py
@@ -1,3 +1,4 @@
+from functools import lru_cache
from pathlib import Path
from loguru import logger
@@ -19,10 +20,26 @@
load_persistent_cache,
save_persistent_cache,
)
-from .utils import get_query_cursor, safe_decode_text, safe_decode_with_fallback
+from .utils import (
+ get_query_cursor,
+ safe_decode_text,
+ safe_decode_with_fallback,
+ sorted_captures,
+)
class ImportProcessor:
+ __slots__ = (
+ "repo_path",
+ "project_name",
+ "ingestor",
+ "function_registry",
+ "import_mapping",
+ "stdlib_extractor",
+ "_is_local_module_cached",
+ "_is_local_java_import_cached",
+ )
+
def __init__(
self,
repo_path: Path,
@@ -39,6 +56,29 @@ def __init__(
function_registry, repo_path, project_name
)
+ repo_is_package = (repo_path / cs.INIT_PY).is_file()
+
+ @lru_cache(maxsize=4096)
+ def _is_local_module_cached(module_name: str) -> bool:
+ # (H) When the repo root is itself a package, its children are importable
+ # (H) only under the package name (project_name.child), never as bare
+ # (H) top-level names, so a bare top-level import resolves externally.
+ if repo_is_package:
+ return module_name == project_name
+ return (
+ (repo_path / module_name).is_dir()
+ or (repo_path / f"{module_name}{cs.EXT_PY}").is_file()
+ or (repo_path / module_name / cs.INIT_PY).is_file()
+ )
+
+ @lru_cache(maxsize=4096)
+ def _is_local_java_import_cached(import_path: str) -> bool:
+ top_level = import_path.split(cs.SEPARATOR_DOT)[0]
+ return (repo_path / top_level).is_dir()
+
+ self._is_local_module_cached = _is_local_module_cached
+ self._is_local_java_import_cached = _is_local_java_import_cached
+
load_persistent_cache()
def __del__(self) -> None:
@@ -65,6 +105,7 @@ def parse_imports(
module_qn: str,
language: cs.SupportedLanguage,
queries: dict[cs.SupportedLanguage, LanguageQueries],
+ pre_captures: dict | None = None,
) -> None:
if language not in queries:
return
@@ -77,8 +118,11 @@ def parse_imports(
self.import_mapping[module_qn] = {}
try:
- cursor = get_query_cursor(imports_query)
- captures = cursor.captures(root_node)
+ if pre_captures is not None:
+ captures = pre_captures
+ else:
+ cursor = get_query_cursor(imports_query)
+ captures = sorted_captures(cursor, root_node)
match language:
case cs.SupportedLanguage.PYTHON:
@@ -95,13 +139,15 @@ def parse_imports(
self._parse_cpp_imports(captures, module_qn)
case cs.SupportedLanguage.LUA:
self._parse_lua_imports(captures, module_qn)
+ case cs.SupportedLanguage.PHP:
+ self._parse_php_imports(captures, module_qn)
case _:
self._parse_generic_imports(captures, module_qn, lang_config)
logger.debug(
- ls.IMP_PARSED_COUNT.format(
- count=len(self.import_mapping[module_qn]), module=module_qn
- )
+ ls.IMP_PARSED_COUNT,
+ count=len(self.import_mapping[module_qn]),
+ module=module_qn,
)
if self.ingestor:
@@ -124,15 +170,14 @@ def parse_imports(
),
)
logger.debug(
- ls.IMP_CREATED_RELATIONSHIP.format(
- from_module=module_qn,
- to_module=module_path,
- full_name=full_name,
- )
+ ls.IMP_CREATED_RELATIONSHIP,
+ from_module=module_qn,
+ to_module=module_path,
+ full_name=full_name,
)
except Exception as e:
- logger.warning(ls.IMP_PARSE_FAILED.format(module=module_qn, error=e))
+ logger.warning(ls.IMP_PARSE_FAILED, module=module_qn, error=e)
def _parse_python_imports(self, captures: dict, module_qn: str) -> None:
all_imports = captures.get(cs.CAPTURE_IMPORT, []) + captures.get(
@@ -159,7 +204,7 @@ def _handle_dotted_name_import(self, child: Node, module_qn: str) -> None:
local_name = module_name.split(cs.SEPARATOR_DOT)[0]
full_name = self._resolve_import_full_name(module_name, local_name)
self.import_mapping[module_qn][local_name] = full_name
- logger.debug(ls.IMP_IMPORT.format(local=local_name, full=full_name))
+ logger.debug(ls.IMP_IMPORT, local=local_name, full=full_name)
def _handle_aliased_import(self, child: Node, module_qn: str) -> None:
module_name_node = child.child_by_field_name(cs.FIELD_NAME)
@@ -175,23 +220,22 @@ def _handle_aliased_import(self, child: Node, module_qn: str) -> None:
top_level = module_name.split(cs.SEPARATOR_DOT)[0]
full_name = self._resolve_import_full_name(module_name, top_level)
self.import_mapping[module_qn][alias] = full_name
- logger.debug(ls.IMP_ALIASED_IMPORT.format(alias=alias, full=full_name))
+ logger.debug(ls.IMP_ALIASED_IMPORT, alias=alias, full=full_name)
def _resolve_import_full_name(self, module_name: str, top_level: str) -> str:
+ if module_name == self.project_name or module_name.startswith(
+ self.project_name + cs.SEPARATOR_DOT
+ ):
+ return module_name
if self._is_local_module(top_level):
return f"{self.project_name}{cs.SEPARATOR_DOT}{module_name}"
return module_name
def _is_local_module(self, module_name: str) -> bool:
- return (
- (self.repo_path / module_name).is_dir()
- or (self.repo_path / f"{module_name}{cs.EXT_PY}").is_file()
- or (self.repo_path / module_name / cs.INIT_PY).is_file()
- )
+ return self._is_local_module_cached(module_name)
def _is_local_java_import(self, import_path: str) -> bool:
- top_level = import_path.split(cs.SEPARATOR_DOT)[0]
- return (self.repo_path / top_level).is_dir()
+ return self._is_local_java_import_cached(import_path)
def _resolve_java_import_path(self, import_path: str) -> str:
if self._is_local_java_import(import_path):
@@ -364,16 +408,26 @@ def _register_python_from_imports(
if is_wildcard:
wildcard_key = f"*{base_module}"
self.import_mapping[module_qn][wildcard_key] = base_module
- logger.debug(ls.IMP_WILDCARD_IMPORT.format(module=base_module))
+ logger.debug(ls.IMP_WILDCARD_IMPORT, module=base_module)
return
for local_name, original_name in imported_items:
full_name = f"{base_module}{cs.SEPARATOR_DOT}{original_name}"
self.import_mapping[module_qn][local_name] = full_name
- logger.debug(ls.IMP_FROM_IMPORT.format(local=local_name, full=full_name))
+ logger.debug(ls.IMP_FROM_IMPORT, local=local_name, full=full_name)
+
+ def _is_package_qn(self, module_qn: str) -> bool:
+ prefix = self.project_name + cs.SEPARATOR_DOT
+ if not module_qn.startswith(prefix):
+ return False
+ rel = module_qn[len(prefix) :].replace(cs.SEPARATOR_DOT, cs.SEPARATOR_SLASH)
+ return (self.repo_path / rel / cs.INIT_PY).is_file()
def _resolve_relative_import(self, relative_node: Node, module_qn: str) -> str:
- module_parts = module_qn.split(cs.SEPARATOR_DOT)[1:]
+ # (H) Relative imports are always internal; resolve to the full project-
+ # (H) prefixed qualified name so resolution does not depend on bare-name
+ # (H) locality checks (which treat package children as external).
+ module_parts = module_qn.split(cs.SEPARATOR_DOT)
dots = 0
module_name = ""
@@ -386,11 +440,21 @@ def _resolve_relative_import(self, relative_node: Node, module_qn: str) -> str:
if decoded_name := safe_decode_text(child):
module_name = decoded_name
- target_parts = module_parts[:-dots] if dots > 0 else module_parts
+ # (H) A package's qualified name already IS the package, so `from .` inside
+ # (H) an __init__.py drops one fewer level than inside a regular module.
+ drop = dots - 1 if self._is_package_qn(module_qn) else dots
+ keep = max(len(module_parts) - drop, 0)
+ target_parts = module_parts[:keep]
if module_name:
target_parts.extend(module_name.split(cs.SEPARATOR_DOT))
+ # (H) A relative climb that lands at the project root (e.g. `from . import x`
+ # (H) in a top-level module) leaves no parts; resolve it to the project root
+ # (H) so the import is not silently dropped.
+ if not target_parts:
+ return self.project_name
+
return cs.SEPARATOR_DOT.join(target_parts)
def _parse_js_ts_imports(self, captures: dict, module_qn: str) -> None:
@@ -446,7 +510,7 @@ def _parse_js_import_clause(
f"{source_module}{cs.IMPORT_DEFAULT_SUFFIX}"
)
logger.debug(
- ls.IMP_JS_DEFAULT.format(name=imported_name, module=source_module)
+ ls.IMP_JS_DEFAULT, name=imported_name, module=source_module
)
elif child.type == cs.TS_NAMED_IMPORTS:
@@ -465,11 +529,10 @@ def _parse_js_import_clause(
f"{source_module}{cs.SEPARATOR_DOT}{imported_name}"
)
logger.debug(
- ls.IMP_JS_NAMED.format(
- local=local_name,
- module=source_module,
- name=imported_name,
- )
+ ls.IMP_JS_NAMED,
+ local=local_name,
+ module=source_module,
+ name=imported_name,
)
elif child.type == cs.TS_NAMESPACE_IMPORT:
@@ -480,9 +543,9 @@ def _parse_js_import_clause(
source_module
)
logger.debug(
- ls.IMP_JS_NAMESPACE.format(
- name=namespace_name, module=source_module
- )
+ ls.IMP_JS_NAMESPACE,
+ name=namespace_name,
+ module=source_module,
)
break
@@ -521,9 +584,9 @@ def _parse_js_require(self, decl_node: Node, current_module: str) -> None:
resolved_module
)
logger.debug(
- ls.IMP_JS_REQUIRE.format(
- var=var_name, module=resolved_module
- )
+ ls.IMP_JS_REQUIRE,
+ var=var_name,
+ module=resolved_module,
)
break
@@ -544,7 +607,7 @@ def _parse_js_reexport(self, export_node: Node, current_module: str) -> None:
if child.type == cs.TS_ASTERISK:
wildcard_key = f"*{source_module}"
self.import_mapping[current_module][wildcard_key] = source_module
- logger.debug(ls.IMP_JS_NAMESPACE_REEXPORT.format(module=source_module))
+ logger.debug(ls.IMP_JS_NAMESPACE_REEXPORT, module=source_module)
elif child.type == cs.TS_EXPORT_CLAUSE:
for grandchild in child.children:
if grandchild.type == cs.TS_EXPORT_SPECIFIER:
@@ -561,11 +624,10 @@ def _parse_js_reexport(self, export_node: Node, current_module: str) -> None:
f"{source_module}{cs.SEPARATOR_DOT}{original_name}"
)
logger.debug(
- ls.IMP_JS_REEXPORT.format(
- exported=exported_name,
- module=source_module,
- original=original_name,
- )
+ ls.IMP_JS_REEXPORT,
+ exported=exported_name,
+ module=source_module,
+ original=original_name,
)
def _parse_java_imports(self, captures: dict, module_qn: str) -> None:
@@ -589,22 +651,22 @@ def _parse_java_imports(self, captures: dict, module_qn: str) -> None:
resolved_path = self._resolve_java_import_path(imported_path)
if is_wildcard:
- logger.debug(ls.IMP_JAVA_WILDCARD.format(path=resolved_path))
+ logger.debug(ls.IMP_JAVA_WILDCARD, path=resolved_path)
self.import_mapping[module_qn][f"*{resolved_path}"] = resolved_path
elif parts := resolved_path.split(cs.SEPARATOR_DOT):
imported_name = parts[-1]
self.import_mapping[module_qn][imported_name] = resolved_path
if is_static:
logger.debug(
- ls.IMP_JAVA_STATIC.format(
- name=imported_name, path=resolved_path
- )
+ ls.IMP_JAVA_STATIC,
+ name=imported_name,
+ path=resolved_path,
)
else:
logger.debug(
- ls.IMP_JAVA_IMPORT.format(
- name=imported_name, path=resolved_path
- )
+ ls.IMP_JAVA_IMPORT,
+ name=imported_name,
+ path=resolved_path,
)
def _parse_rust_imports(self, captures: dict, module_qn: str) -> None:
@@ -617,7 +679,7 @@ def _parse_rust_use_declaration(self, use_node: Node, module_qn: str) -> None:
for imported_name, full_path in imports.items():
self.import_mapping[module_qn][imported_name] = full_path
- logger.debug(ls.IMP_RUST.format(name=imported_name, path=full_path))
+ logger.debug(ls.IMP_RUST, name=imported_name, path=full_path)
def _parse_go_imports(self, captures: dict, module_qn: str) -> None:
for import_node in captures.get(cs.CAPTURE_IMPORT, []):
@@ -646,7 +708,7 @@ def _parse_go_import_spec(self, spec_node: Node, module_qn: str) -> None:
if import_path:
package_name = alias_name or import_path.split(cs.SEPARATOR_SLASH)[-1]
self.import_mapping[module_qn][package_name] = import_path
- logger.debug(ls.IMP_GO.format(package=package_name, path=import_path))
+ logger.debug(ls.IMP_GO, package=package_name, path=import_path)
def _parse_cpp_imports(self, captures: dict, module_qn: str) -> None:
for import_node in captures.get(cs.CAPTURE_IMPORT, []):
@@ -692,9 +754,10 @@ def _parse_cpp_include(self, include_node: Node, module_qn: str) -> None:
self.import_mapping[module_qn][local_name] = full_name
logger.debug(
- ls.IMP_CPP_INCLUDE.format(
- local=local_name, full=full_name, system=is_system_include
- )
+ ls.IMP_CPP_INCLUDE,
+ local=local_name,
+ full=full_name,
+ system=is_system_include,
)
def _parse_cpp_module_import(self, import_node: Node, module_qn: str) -> None:
@@ -727,7 +790,7 @@ def _parse_cpp_module_import(self, import_node: Node, module_qn: str) -> None:
full_name = f"{cs.IMPORT_STD_PREFIX}{module_name}"
self.import_mapping[module_qn][local_name] = full_name
- logger.debug(ls.IMP_CPP_MODULE.format(local=local_name, full=full_name))
+ logger.debug(ls.IMP_CPP_MODULE, local=local_name, full=full_name)
def _parse_cpp_module_declaration(self, decl_node: Node, module_qn: str) -> None:
decoded_text = safe_decode_text(decl_node)
@@ -757,9 +820,9 @@ def _parse_cpp_module_declaration(self, decl_node: Node, module_qn: str) -> None
full_name = f"{self.project_name}{cs.SEPARATOR_DOT}{partition_part}"
self.import_mapping[module_qn][partition_name] = full_name
logger.debug(
- ls.IMP_CPP_PARTITION.format(
- partition=partition_name, full=full_name
- )
+ ls.IMP_CPP_PARTITION,
+ partition=partition_name,
+ full=full_name,
)
def _register_cpp_module_mapping(
@@ -769,16 +832,74 @@ def _register_cpp_module_mapping(
self.import_mapping[module_qn][module_name] = (
f"{self.project_name}{cs.SEPARATOR_DOT}{module_name}"
)
- logger.debug(log_template.format(name=module_name))
+ logger.debug(log_template, name=module_name)
+
+ _PHP_INCLUDE_REQUIRE_TYPES = frozenset(
+ {
+ cs.TS_PHP_INCLUDE_EXPRESSION,
+ cs.TS_PHP_INCLUDE_ONCE_EXPRESSION,
+ cs.TS_PHP_REQUIRE_EXPRESSION,
+ cs.TS_PHP_REQUIRE_ONCE_EXPRESSION,
+ }
+ )
+
+ def _parse_php_imports(self, captures: dict, module_qn: str) -> None:
+ all_imports = captures.get(cs.CAPTURE_IMPORT, []) + captures.get(
+ cs.CAPTURE_IMPORT_FROM, []
+ )
+ for import_node in all_imports:
+ if import_node.type == cs.TS_PHP_NAMESPACE_USE_DECLARATION:
+ self._handle_php_use_declaration(import_node, module_qn)
+ elif import_node.type in self._PHP_INCLUDE_REQUIRE_TYPES:
+ self._handle_php_include_require(import_node, module_qn)
+
+ def _handle_php_use_declaration(self, use_node: Node, module_qn: str) -> None:
+ for child in use_node.named_children:
+ if child.type != cs.TS_PHP_NAMESPACE_USE_CLAUSE:
+ continue
+ qn_node = next(
+ (c for c in child.named_children if c.type == cs.TS_PHP_QUALIFIED_NAME),
+ None,
+ )
+ if not qn_node:
+ continue
+ imported_path = safe_decode_with_fallback(qn_node)
+ if not imported_path:
+ continue
+ imported_path = imported_path.replace("\\", cs.SEPARATOR_DOT)
+ alias_node = child.child_by_field_name("alias")
+ if alias_node and alias_node.text:
+ local_name = safe_decode_with_fallback(alias_node)
+ else:
+ parts = imported_path.split(cs.SEPARATOR_DOT)
+ local_name = parts[-1] if parts else imported_path
+ self.import_mapping[module_qn][local_name] = imported_path
+
+ def _handle_php_include_require(self, node: Node, module_qn: str) -> None:
+ for child in node.children:
+ if child.type in {"string", "encapsed_string"}:
+ raw = safe_decode_with_fallback(child)
+ if not raw:
+ continue
+ path_str = raw.strip("'\"")
+ path_str = path_str.replace("/", cs.SEPARATOR_DOT).replace(
+ "\\", cs.SEPARATOR_DOT
+ )
+ if path_str.endswith(".php"):
+ path_str = path_str[:-4]
+ parts = path_str.split(cs.SEPARATOR_DOT)
+ local_name = parts[-1] if parts else path_str
+ self.import_mapping[module_qn][local_name] = path_str
+ return
def _parse_generic_imports(
self, captures: dict, module_qn: str, lang_config: LanguageSpec
) -> None:
for import_node in captures.get(cs.CAPTURE_IMPORT, []):
logger.debug(
- ls.IMP_GENERIC.format(
- language=lang_config.language, node_type=import_node.type
- )
+ ls.IMP_GENERIC,
+ language=lang_config.language,
+ node_type=import_node.type,
)
def _parse_lua_imports(self, captures: dict, module_qn: str) -> None:
diff --git a/codebase_rag/parsers/java/method_resolver.py b/codebase_rag/parsers/java/method_resolver.py
index 01bd25cae..08b9514fb 100644
--- a/codebase_rag/parsers/java/method_resolver.py
+++ b/codebase_rag/parsers/java/method_resolver.py
@@ -8,9 +8,14 @@
from ... import constants as cs
from ... import logs as ls
+from ...decorators import recursion_guard
from ...types_defs import ASTNode, NodeType
from ..utils import safe_decode_text
-from .utils import extract_method_call_info, get_class_context_from_qn
+from .utils import (
+ extract_class_info,
+ extract_method_call_info,
+ get_class_context_from_qn,
+)
if TYPE_CHECKING:
from pathlib import Path
@@ -20,6 +25,7 @@
class JavaMethodResolverMixin:
+ __slots__ = ()
import_processor: ImportProcessor
function_registry: FunctionRegistryTrieProtocol
project_name: str
@@ -53,14 +59,29 @@ def _get_current_class_name(self, module_qn: str) -> str | None: ...
@abstractmethod
def _lookup_variable_type(self, var_name: str, module_qn: str) -> str | None: ...
+ @abstractmethod
+ def _lookup_java_field_type(
+ self, class_type: str, field_name: str, module_qn: str
+ ) -> str | None: ...
+
+ @abstractmethod
+ def _find_containing_java_class(self, node: ASTNode) -> ASTNode | None: ...
+
def _resolve_java_object_type(
- self, object_ref: str, local_var_types: dict[str, str], module_qn: str
+ self,
+ object_ref: str,
+ local_var_types: dict[str, str],
+ module_qn: str,
+ context_node: ASTNode | None = None,
) -> str | None:
if object_ref in local_var_types:
return local_var_types[object_ref]
- # (H) Check for 'this' reference - find the containing class (using trie for O(k) lookup)
+ # (H) Check for 'this' reference - prefer the lexical containing class (precise in
+ # (H) multi-class files); fall back to the first class under the module otherwise.
if object_ref == cs.JAVA_KEYWORD_THIS:
+ if lexical := self._lexical_class_qn(context_node, module_qn):
+ return lexical
return next(
(
str(qn)
@@ -72,8 +93,13 @@ def _resolve_java_object_type(
None,
)
- # (H) Check for 'super' reference - for super calls, look at parent classes (using trie for O(k) lookup)
+ # (H) Check for 'super' reference - resolve the lexical class then its parent when
+ # (H) available; otherwise fall back to the first class under the module with a parent.
if object_ref == cs.JAVA_KEYWORD_SUPER:
+ if (lexical := self._lexical_class_qn(context_node, module_qn)) and (
+ parent_qn := self._find_parent_class(lexical)
+ ):
+ return parent_qn
for qn, entity_type in self.function_registry.find_with_prefix(module_qn):
if entity_type == NodeType.CLASS:
if parent_qn := self._find_parent_class(qn):
@@ -92,8 +118,54 @@ def _resolve_java_object_type(
):
return simple_class_qn
+ # (H) A receiver like `obj.engine` (field access on a typed variable) is not a
+ # (H) single name: resolve the base, then walk each field's declared type across
+ # (H) classes so `obj.engine.start()` and deeper chains resolve to a method.
+ if cs.SEPARATOR_DOT in object_ref:
+ return self._resolve_field_access_chain_type(
+ object_ref, local_var_types, module_qn, context_node
+ )
+
return None
+ def _lexical_class_qn(
+ self, context_node: ASTNode | None, module_qn: str
+ ) -> str | None:
+ if context_node is None:
+ return None
+ if not (class_node := self._find_containing_java_class(context_node)):
+ return None
+ if not (class_name := extract_class_info(class_node).get(cs.FIELD_NAME)):
+ return None
+ return self._resolve_java_type_name(class_name, module_qn)
+
+ def _resolve_field_access_chain_type(
+ self,
+ object_ref: str,
+ local_var_types: dict[str, str],
+ module_qn: str,
+ context_node: ASTNode | None = None,
+ ) -> str | None:
+ parts = object_ref.split(cs.SEPARATOR_DOT)
+ if len(parts) < 2:
+ return None
+
+ current_type = self._resolve_java_object_type(
+ parts[0], local_var_types, module_qn, context_node
+ )
+ if not current_type:
+ return None
+
+ for field_name in parts[1:]:
+ next_type = self._lookup_java_field_type(
+ current_type, field_name, module_qn
+ )
+ if not next_type:
+ return None
+ current_type = next_type
+
+ return current_type
+
def _find_parent_class(self, class_qn: str) -> str | None:
parent_classes = self.class_inheritance.get(class_qn, [])
return parent_classes[0] if parent_classes else None
@@ -202,6 +274,10 @@ def _is_matching_method(self, member: str, method_name: str) -> bool:
or member == f"{method_name}{cs.EMPTY_PARENS}"
)
+ @recursion_guard(
+ key_func=lambda self, class_qn, *_, **__: class_qn,
+ guard_name=cs.GUARD_INHERITED_METHOD,
+ )
def _find_inherited_method(
self, class_qn: str, method_name: str, module_qn: str
) -> tuple[str, str] | None:
@@ -235,8 +311,10 @@ def _resolve_java_method_return_type(
parts = method_call.split(cs.SEPARATOR_DOT)
if len(parts) < 2:
method_name = method_call
- if current_class_qn := self._get_current_class_name(module_qn):
- return self._find_method_return_type(current_class_qn, method_name)
+ if (current_class_qn := self._get_current_class_name(module_qn)) and (
+ result := self._find_method_return_type(current_class_qn, method_name)
+ ):
+ return result
else:
object_part = cs.SEPARATOR_DOT.join(parts[:-1])
method_name = parts[-1]
@@ -348,34 +426,32 @@ def _do_resolve_java_method_call(
logger.debug(ls.JAVA_NO_METHOD_NAME)
return None
- logger.debug(
- ls.JAVA_RESOLVING_CALL.format(method=method_name, object=object_ref)
- )
+ logger.debug(ls.JAVA_RESOLVING_CALL, method=method_name, object=object_ref)
if not object_ref:
- logger.debug(ls.JAVA_RESOLVING_STATIC.format(method=method_name))
+ logger.debug(ls.JAVA_RESOLVING_STATIC, method=method_name)
result = self._resolve_static_or_local_method(str(method_name), module_qn)
if result:
- logger.debug(ls.JAVA_FOUND_STATIC.format(result=result))
+ logger.debug(ls.JAVA_FOUND_STATIC, result=result)
else:
- logger.debug(ls.JAVA_STATIC_NOT_FOUND.format(method=method_name))
+ logger.debug(ls.JAVA_STATIC_NOT_FOUND, method=method_name)
return result
- logger.debug(ls.JAVA_RESOLVING_OBJ_TYPE.format(object=object_ref))
+ logger.debug(ls.JAVA_RESOLVING_OBJ_TYPE, object=object_ref)
if not (
object_type := self._resolve_java_object_type(
- str(object_ref), local_var_types, module_qn
+ str(object_ref), local_var_types, module_qn, call_node
)
):
- logger.debug(ls.JAVA_OBJ_TYPE_UNKNOWN.format(object=object_ref))
+ logger.debug(ls.JAVA_OBJ_TYPE_UNKNOWN, object=object_ref)
return None
- logger.debug(ls.JAVA_OBJ_TYPE_RESOLVED.format(type=object_type))
+ logger.debug(ls.JAVA_OBJ_TYPE_RESOLVED, type=object_type)
result = self._resolve_instance_method(object_type, str(method_name), module_qn)
if result:
- logger.debug(ls.JAVA_FOUND_INSTANCE.format(result=result))
+ logger.debug(ls.JAVA_FOUND_INSTANCE, result=result)
else:
logger.debug(
- ls.JAVA_INSTANCE_NOT_FOUND.format(type=object_type, method=method_name)
+ ls.JAVA_INSTANCE_NOT_FOUND, type=object_type, method=method_name
)
return result
diff --git a/codebase_rag/parsers/java/type_inference.py b/codebase_rag/parsers/java/type_inference.py
index 8fd86a7d2..2e949e5f5 100644
--- a/codebase_rag/parsers/java/type_inference.py
+++ b/codebase_rag/parsers/java/type_inference.py
@@ -26,6 +26,21 @@ class JavaTypeInferenceEngine(
JavaVariableAnalyzerMixin,
JavaMethodResolverMixin,
):
+ __slots__ = (
+ "import_processor",
+ "function_registry",
+ "repo_path",
+ "project_name",
+ "ast_cache",
+ "queries",
+ "module_qn_to_file_path",
+ "class_inheritance",
+ "simple_name_lookup",
+ "_lookup_cache",
+ "_lookup_in_progress",
+ "_fqn_to_module_qn",
+ )
+
def __init__(
self,
import_processor: ImportProcessor,
@@ -83,17 +98,19 @@ def build_variable_type_map(
try:
self._collect_all_variable_types(scope_node, local_var_types, module_qn)
- logger.debug(ls.JAVA_VAR_TYPE_MAP_BUILT.format(count=len(local_var_types)))
+ logger.debug(ls.JAVA_VAR_TYPE_MAP_BUILT, count=len(local_var_types))
except Exception as e:
- logger.error(ls.JAVA_VAR_TYPE_MAP_FAILED.format(error=e))
+ logger.error(ls.JAVA_VAR_TYPE_MAP_FAILED, error=e)
return local_var_types
def resolve_java_method_call(
- self, call_node: ASTNode, local_var_types: dict[str, str], module_qn: str
+ self, call_node: ASTNode, local_var_types: dict[str, str] | None, module_qn: str
) -> tuple[str, str] | None:
- return self._do_resolve_java_method_call(call_node, local_var_types, module_qn)
+ return self._do_resolve_java_method_call(
+ call_node, local_var_types or {}, module_qn
+ )
def _find_containing_java_class(self, node: ASTNode) -> ASTNode | None:
current = node.parent
diff --git a/codebase_rag/parsers/java/type_resolver.py b/codebase_rag/parsers/java/type_resolver.py
index cbb69fcf7..f1827e6e5 100644
--- a/codebase_rag/parsers/java/type_resolver.py
+++ b/codebase_rag/parsers/java/type_resolver.py
@@ -20,6 +20,7 @@
class JavaTypeResolverMixin:
+ __slots__ = ()
import_processor: ImportProcessor
function_registry: FunctionRegistryTrieProtocol
module_qn_to_file_path: dict[str, Path]
diff --git a/codebase_rag/parsers/java/utils.py b/codebase_rag/parsers/java/utils.py
index f267afe47..77784a746 100644
--- a/codebase_rag/parsers/java/utils.py
+++ b/codebase_rag/parsers/java/utils.py
@@ -114,15 +114,36 @@ def _extract_superclass(class_node: ASTNode) -> str | None:
superclass_node = class_node.child_by_field_name(cs.TS_FIELD_SUPERCLASS)
if not superclass_node:
return None
+ return _extract_type_identifier_name(superclass_node)
- match superclass_node.type:
+
+def _extract_type_identifier_name(node: ASTNode) -> str | None:
+ match node.type:
case cs.TS_TYPE_IDENTIFIER:
- return safe_decode_text(superclass_node)
+ return safe_decode_text(node)
+ case cs.TS_SCOPED_TYPE_IDENTIFIER:
+ # (H) `Outer.Base`/`pkg.Base`: keep the full scoped name rather than
+ # (H) descending to the first segment (the outer/package), which would
+ # (H) point resolution at the wrong class.
+ return safe_decode_text(node)
case cs.TS_GENERIC_TYPE:
- for child in superclass_node.children:
- if child.type == cs.TS_TYPE_IDENTIFIER:
+ # (H) The base of a generic type is its first type_identifier/scoped child
+ # (H) (e.g. `Box` -> Box, `Outer.Base` -> Outer.Base); ignore the
+ # (H) type_arguments that follow.
+ for child in node.children:
+ if child.type in (
+ cs.TS_TYPE_IDENTIFIER,
+ cs.TS_SCOPED_TYPE_IDENTIFIER,
+ ):
return safe_decode_text(child)
- return None
+ return None
+ case _:
+ # (H) `extends X` exposes a `superclass` wrapper node, not the type itself;
+ # (H) descend into it to reach the type_identifier/generic_type.
+ for child in node.children:
+ if name := _extract_type_identifier_name(child):
+ return name
+ return None
def _extract_interface_name(type_child: ASTNode) -> str | None:
diff --git a/codebase_rag/parsers/java/variable_analyzer.py b/codebase_rag/parsers/java/variable_analyzer.py
index 65003d9bb..022ddf18d 100644
--- a/codebase_rag/parsers/java/variable_analyzer.py
+++ b/codebase_rag/parsers/java/variable_analyzer.py
@@ -23,8 +23,10 @@
class JavaVariableAnalyzerMixin:
+ __slots__ = ()
ast_cache: ASTCacheProtocol
module_qn_to_file_path: dict[str, Path]
+ class_inheritance: dict[str, list[str]]
_lookup_cache: dict[str, str | None]
_lookup_in_progress: set[str]
@@ -84,7 +86,7 @@ def _process_formal_parameter(
if param_name and param_type:
resolved_type = self._resolve_java_type_name(param_type, module_qn)
local_var_types[param_name] = resolved_type
- logger.debug(ls.JAVA_PARAM.format(name=param_name, type=resolved_type))
+ logger.debug(ls.JAVA_PARAM, name=param_name, type=resolved_type)
def _process_spread_parameter(
self, param_node: ASTNode, local_var_types: dict[str, str], module_qn: str
@@ -103,9 +105,7 @@ def _process_spread_parameter(
if param_name and param_type:
resolved_type = self._resolve_java_type_name(param_type, module_qn)
local_var_types[param_name] = resolved_type
- logger.debug(
- ls.JAVA_VARARGS_PARAM.format(name=param_name, type=resolved_type)
- )
+ logger.debug(ls.JAVA_VARARGS_PARAM, name=param_name, type=resolved_type)
def _analyze_java_local_variables(
self, scope_node: ASTNode, local_var_types: dict[str, str], module_qn: str
@@ -164,15 +164,13 @@ def _process_variable_declarator(
resolved_type = self._resolve_java_type_name(inferred_type, module_qn)
local_var_types[var_name] = resolved_type
logger.debug(
- ls.JAVA_LOCAL_VAR_INFERRED.format(name=var_name, type=resolved_type)
+ ls.JAVA_LOCAL_VAR_INFERRED, name=var_name, type=resolved_type
)
return
resolved_type = self._resolve_java_type_name(declared_type, module_qn)
local_var_types[var_name] = resolved_type
- logger.debug(
- ls.JAVA_LOCAL_VAR_DECLARED.format(name=var_name, type=resolved_type)
- )
+ logger.debug(ls.JAVA_LOCAL_VAR_DECLARED, name=var_name, type=resolved_type)
def _analyze_java_class_fields(
self, scope_node: ASTNode, local_var_types: dict[str, str], module_qn: str
@@ -201,7 +199,7 @@ def _analyze_java_class_fields(
if str(field_name) not in local_var_types:
local_var_types[str(field_name)] = resolved_type
logger.debug(
- ls.JAVA_CLASS_FIELD.format(name=field_name, type=resolved_type)
+ ls.JAVA_CLASS_FIELD, name=field_name, type=resolved_type
)
def _analyze_java_constructor_assignments(
@@ -235,7 +233,7 @@ def _process_java_assignment(
):
resolved_type = self._resolve_java_type_name(inferred_type, module_qn)
local_var_types[var_name] = resolved_type
- logger.debug(ls.JAVA_ASSIGNMENT.format(name=var_name, type=resolved_type))
+ logger.debug(ls.JAVA_ASSIGNMENT, name=var_name, type=resolved_type)
def _extract_java_variable_reference(self, node: ASTNode) -> str | None:
match node.type:
@@ -297,9 +295,7 @@ def _register_for_loop_variable(
):
resolved_type = self._resolve_java_type_name(var_type, module_qn)
local_var_types[var_name] = resolved_type
- logger.debug(
- ls.JAVA_ENHANCED_FOR_VAR.format(name=var_name, type=resolved_type)
- )
+ logger.debug(ls.JAVA_ENHANCED_FOR_VAR, name=var_name, type=resolved_type)
def _extract_for_loop_variable_from_children(
self, for_node: ASTNode, local_var_types: dict[str, str], module_qn: str
@@ -325,9 +321,9 @@ def _extract_for_loop_variable_from_children(
)
local_var_types[var_name] = resolved_type
logger.debug(
- ls.JAVA_ENHANCED_FOR_VAR_ALT.format(
- name=var_name, type=resolved_type
- )
+ ls.JAVA_ENHANCED_FOR_VAR_ALT,
+ name=var_name,
+ type=resolved_type,
)
break
@@ -399,16 +395,51 @@ def _infer_java_field_access_type(
if not object_node or not field_node:
return None
- object_name = safe_decode_text(object_node)
field_name = safe_decode_text(field_node)
-
- if not object_name or not field_name:
+ if not field_name:
return None
- if object_type := self._lookup_variable_type(object_name, module_qn):
+ # (H) A nested receiver (`obj.address.zipCode`) has a field_access as its object;
+ # (H) recurse to infer that inner type before looking up the outer field, so
+ # (H) multi-level field access resolves rather than failing on a non-variable name.
+ if object_node.type == cs.TS_FIELD_ACCESS:
+ object_type = self._infer_java_field_access_type(object_node, module_qn)
+ elif object_name := safe_decode_text(object_node):
+ object_type = self._resolve_field_access_base_type(
+ object_name, field_access_node, module_qn
+ )
+ else:
+ object_type = None
+
+ if object_type:
return self._lookup_java_field_type(object_type, field_name, module_qn)
return None
+ def _resolve_field_access_base_type(
+ self, object_name: str, field_access_node: ASTNode, module_qn: str
+ ) -> str | None:
+ # (H) `this`/`super` are receiver keywords, not variables: resolve them to the
+ # (H) containing class (or its superclass) so nested chains rooted at them
+ # (H) (e.g. `var c = this.address.city`) infer a type instead of failing.
+ if object_name in (cs.JAVA_KEYWORD_THIS, cs.JAVA_KEYWORD_SUPER):
+ if not (class_node := self._find_containing_java_class(field_access_node)):
+ return None
+ class_info = extract_class_info(class_node)
+ class_name = class_info.get(cs.FIELD_NAME)
+ if object_name == cs.JAVA_KEYWORD_THIS:
+ return class_name
+ # (H) `super`: return the fully-qualified parent from class_inheritance so a
+ # (H) nested superclass (`Outer.Base`) resolves; the relative name from the
+ # (H) AST would be treated as an absolute class key by the field lookup.
+ if class_name:
+ own_qn = self._resolve_java_type_name(class_name, module_qn)
+ if cs.SEPARATOR_DOT not in own_qn:
+ own_qn = f"{module_qn}{cs.SEPARATOR_DOT}{own_qn}"
+ if parents := self.class_inheritance.get(own_qn):
+ return parents[0]
+ return class_info.get(cs.FIELD_SUPERCLASS)
+ return self._lookup_variable_type(object_name, module_qn)
+
def _lookup_variable_type(self, var_name: str, module_qn: str) -> str | None:
if not var_name or not module_qn:
return None
@@ -448,45 +479,82 @@ def _lookup_java_field_type(
if not class_type or not field_name:
return None
- resolved_class_type = self._resolve_java_type_name(class_type, module_qn)
-
- class_qn = (
- resolved_class_type
- if cs.SEPARATOR_DOT in resolved_class_type
- else f"{module_qn}{cs.SEPARATOR_DOT}{resolved_class_type}"
+ resolved = self._resolve_java_type_name(class_type, module_qn)
+ class_qn: str | None = (
+ resolved
+ if cs.SEPARATOR_DOT in resolved
+ else f"{module_qn}{cs.SEPARATOR_DOT}{resolved}"
)
- parts = class_qn.split(cs.SEPARATOR_DOT)
- if len(parts) < 2:
- return None
-
- target_module_qn = cs.SEPARATOR_DOT.join(parts[:-1])
- target_class_name = parts[-1]
-
- file_path = self.module_qn_to_file_path.get(target_module_qn)
- if file_path is None or file_path not in self.ast_cache:
- return None
+ # (H) Walk the inheritance chain using authoritative qualified parents from
+ # (H) class_inheritance: a field accessed on a subclass may be declared on a
+ # (H) superclass, including a nested one like `Outer.Base`. Seen-guarded.
+ seen: set[str] = set()
+ while class_qn and class_qn not in seen:
+ seen.add(class_qn)
+ if located := self._locate_class(class_qn):
+ root_node, class_path, target_module_qn = located
+ if field_type := self._find_field_type_in_nested_class(
+ root_node, class_path, field_name, target_module_qn
+ ):
+ return field_type
+ parents = self.class_inheritance.get(class_qn)
+ class_qn = parents[0] if parents else None
- root_node, _ = self.ast_cache[file_path]
+ return None
- return self._find_field_type_in_class(
- root_node, target_class_name, field_name, target_module_qn
- )
+ def _locate_class(self, class_qn: str) -> tuple[ASTNode, list[str], str] | None:
+ # (H) The file module is the longest registered prefix of the class qn; the
+ # (H) remaining segments are the (possibly nested) class path within that file,
+ # (H) so `proj.pkg.Outer.Base` resolves to file `proj.pkg` + path [Outer, Base].
+ parts = class_qn.split(cs.SEPARATOR_DOT)
+ for split in range(len(parts) - 1, 0, -1):
+ module_candidate = cs.SEPARATOR_DOT.join(parts[:split])
+ file_path = self.module_qn_to_file_path.get(module_candidate)
+ if file_path is not None and file_path in self.ast_cache:
+ root_node, _ = self.ast_cache[file_path]
+ return root_node, parts[split:], module_candidate
+ return None
def _find_field_type_in_class(
self, root_node: ASTNode, class_name: str, field_name: str, module_qn: str
) -> str | None:
- for child in root_node.children:
- if child.type == cs.TS_CLASS_DECLARATION:
- class_info = extract_class_info(child)
- if class_info.get(cs.FIELD_NAME) == class_name:
- if class_body := child.child_by_field_name(cs.FIELD_BODY):
- for field_child in class_body.children:
- if field_child.type == cs.TS_FIELD_DECLARATION:
- field_info = extract_field_info(field_child)
- if field_info.get(cs.FIELD_NAME) == field_name:
- if field_type := field_info.get(cs.FIELD_TYPE):
- return self._resolve_java_type_name(
- str(field_type), module_qn
- )
+ return self._find_field_type_in_nested_class(
+ root_node, [class_name], field_name, module_qn
+ )
+
+ def _find_field_type_in_nested_class(
+ self,
+ root_node: ASTNode,
+ class_path: list[str],
+ field_name: str,
+ module_qn: str,
+ ) -> str | None:
+ children = root_node.children
+ body: ASTNode | None = None
+ for class_name in class_path:
+ class_node = next(
+ (
+ child
+ for child in children
+ if child.type == cs.TS_CLASS_DECLARATION
+ and extract_class_info(child).get(cs.FIELD_NAME) == class_name
+ ),
+ None,
+ )
+ if class_node is None or not (
+ body := class_node.child_by_field_name(cs.FIELD_BODY)
+ ):
+ return None
+ children = body.children
+
+ if body is None:
+ return None
+
+ for field_child in body.children:
+ if field_child.type == cs.TS_FIELD_DECLARATION:
+ field_info = extract_field_info(field_child)
+ if field_info.get(cs.FIELD_NAME) == field_name:
+ if field_type := field_info.get(cs.FIELD_TYPE):
+ return self._resolve_java_type_name(str(field_type), module_qn)
return None
diff --git a/codebase_rag/parsers/js_ts/ingest.py b/codebase_rag/parsers/js_ts/ingest.py
index 30580e184..2641ae367 100644
--- a/codebase_rag/parsers/js_ts/ingest.py
+++ b/codebase_rag/parsers/js_ts/ingest.py
@@ -5,7 +5,7 @@
from typing import TYPE_CHECKING
from loguru import logger
-from tree_sitter import Query, QueryCursor
+from tree_sitter import QueryCursor
from ... import constants as cs
from ... import logs as lg
@@ -16,7 +16,12 @@
PropertyDict,
SimpleNameLookup,
)
-from ..utils import safe_decode_text, safe_decode_with_fallback
+from ..utils import (
+ get_cached_query,
+ safe_decode_text,
+ safe_decode_with_fallback,
+ sorted_captures,
+)
from .module_system import JsTsModuleSystemMixin
from .utils import get_js_ts_language_obj
@@ -29,6 +34,7 @@
class JsTsIngestMixin(JsTsModuleSystemMixin):
+ __slots__ = ()
ingestor: IngestorProtocol
repo_path: Path
project_name: str
@@ -88,14 +94,14 @@ def _ingest_prototype_inheritance_links(
language_obj, root_node, module_qn
)
except Exception as e:
- logger.debug(lg.JS_PROTOTYPE_INHERITANCE_FAILED.format(error=e))
+ logger.debug(lg.JS_PROTOTYPE_INHERITANCE_FAILED, error=e)
def _process_prototype_inheritance_captures(
self, language_obj, root_node, module_qn
):
- query = Query(language_obj, cs.JS_PROTOTYPE_INHERITANCE_QUERY)
+ query = get_cached_query(language_obj, cs.JS_PROTOTYPE_INHERITANCE_QUERY)
cursor = QueryCursor(query)
- captures = cursor.captures(root_node)
+ captures = sorted_captures(cursor, root_node)
child_classes = captures.get(cs.CAPTURE_CHILD_CLASS, [])
parent_classes = captures.get(cs.CAPTURE_PARENT_CLASS, [])
@@ -122,9 +128,7 @@ def _process_prototype_inheritance_captures(
)
logger.debug(
- lg.JS_PROTOTYPE_INHERITANCE.format(
- child_qn=child_qn, parent_qn=parent_qn
- )
+ lg.JS_PROTOTYPE_INHERITANCE, child_qn=child_qn, parent_qn=parent_qn
)
def _ingest_prototype_method_assignments(
@@ -143,12 +147,12 @@ def _ingest_prototype_method_assignments(
try:
self._process_prototype_method_captures(language_obj, root_node, module_qn)
except Exception as e:
- logger.debug(lg.JS_PROTOTYPE_METHODS_FAILED.format(error=e))
+ logger.debug(lg.JS_PROTOTYPE_METHODS_FAILED, error=e)
def _process_prototype_method_captures(self, language_obj, root_node, module_qn):
- method_query = Query(language_obj, cs.JS_PROTOTYPE_METHOD_QUERY)
+ method_query = get_cached_query(language_obj, cs.JS_PROTOTYPE_METHOD_QUERY)
method_cursor = QueryCursor(method_query)
- method_captures = method_cursor.captures(root_node)
+ method_captures = sorted_captures(method_cursor, root_node)
constructor_names = method_captures.get(cs.CAPTURE_CONSTRUCTOR_NAME, [])
method_names = method_captures.get(cs.CAPTURE_METHOD_NAME, [])
@@ -165,6 +169,9 @@ def _process_prototype_method_captures(self, language_obj, root_node, module_qn)
if constructor_name and method_name:
constructor_qn = f"{module_qn}{cs.SEPARATOR_DOT}{constructor_name}"
method_qn = f"{constructor_qn}{cs.SEPARATOR_DOT}{method_name}"
+ method_qn = self.function_registry.register_unique_qn(
+ method_qn, func_node.start_point[0] + 1
+ )
method_props: PropertyDict = {
cs.KEY_QUALIFIED_NAME: method_qn,
@@ -174,9 +181,9 @@ def _process_prototype_method_captures(self, language_obj, root_node, module_qn)
cs.KEY_DOCSTRING: self._get_docstring(func_node),
}
logger.info(
- lg.JS_PROTOTYPE_METHOD_FOUND.format(
- method_name=method_name, method_qn=method_qn
- )
+ lg.JS_PROTOTYPE_METHOD_FOUND,
+ method_name=method_name,
+ method_qn=method_qn,
)
self.ingestor.ensure_node_batch(cs.NodeLabel.FUNCTION, method_props)
@@ -190,9 +197,9 @@ def _process_prototype_method_captures(self, language_obj, root_node, module_qn)
)
logger.debug(
- lg.JS_PROTOTYPE_METHOD_DEFINES.format(
- constructor_qn=constructor_qn, method_qn=method_qn
- )
+ lg.JS_PROTOTYPE_METHOD_DEFINES,
+ constructor_qn=constructor_qn,
+ method_qn=method_qn,
)
def _ingest_object_literal_methods(
@@ -213,7 +220,7 @@ def _ingest_object_literal_methods(
language_obj, query_text, root_node, module_qn, lang_config
)
except Exception as e:
- logger.debug(lg.JS_OBJECT_METHODS_DETECT_FAILED.format(error=e))
+ logger.debug(lg.JS_OBJECT_METHODS_DETECT_FAILED, error=e)
def _process_object_method_query(
self,
@@ -224,9 +231,9 @@ def _process_object_method_query(
lang_config,
) -> None:
try:
- query = Query(language_obj, query_text)
+ query = get_cached_query(language_obj, query_text)
cursor = QueryCursor(query)
- captures = cursor.captures(root_node)
+ captures = sorted_captures(cursor, root_node)
method_names = captures.get(cs.CAPTURE_METHOD_NAME, [])
method_functions = captures.get(cs.CAPTURE_METHOD_FUNCTION, [])
@@ -250,7 +257,7 @@ def _process_object_method_query(
method_name_node, method_func_node, module_qn, lang_config
)
except Exception as e:
- logger.debug(lg.JS_OBJECT_METHODS_PROCESS_FAILED.format(error=e))
+ logger.debug(lg.JS_OBJECT_METHODS_PROCESS_FAILED, error=e)
def _process_single_object_method(
self,
@@ -306,6 +313,9 @@ def _register_object_method(
method_func_node: ASTNode,
module_qn: str,
) -> None:
+ method_qn = self.function_registry.register_unique_qn(
+ method_qn, method_func_node.start_point[0] + 1
+ )
method_props: PropertyDict = {
cs.KEY_QUALIFIED_NAME: method_qn,
cs.KEY_NAME: method_name,
@@ -314,9 +324,7 @@ def _register_object_method(
cs.KEY_DOCSTRING: self._get_docstring(method_func_node),
}
logger.info(
- lg.JS_OBJECT_METHOD_FOUND.format(
- method_name=method_name, method_qn=method_qn
- )
+ lg.JS_OBJECT_METHOD_FOUND, method_name=method_name, method_qn=method_qn
)
self.ingestor.ensure_node_batch(cs.NodeLabel.FUNCTION, method_props)
@@ -352,7 +360,7 @@ def _ingest_assignment_arrow_functions(
lang_query, query_text, root_node, module_qn, lang_config
)
except Exception as e:
- logger.debug(lg.JS_ASSIGNMENT_ARROW_DETECT_FAILED.format(error=e))
+ logger.debug(lg.JS_ASSIGNMENT_ARROW_DETECT_FAILED, error=e)
def _process_arrow_query(
self,
@@ -363,9 +371,9 @@ def _process_arrow_query(
lang_config,
) -> None:
try:
- query = Query(lang_query, query_text)
+ query = get_cached_query(lang_query, query_text)
cursor = QueryCursor(query)
- captures = cursor.captures(root_node)
+ captures = sorted_captures(cursor, root_node)
method_names = captures.get(cs.CAPTURE_METHOD_NAME, [])
member_exprs = captures.get(cs.CAPTURE_MEMBER_EXPR, [])
@@ -390,7 +398,7 @@ def _process_arrow_query(
lg.JS_ASSIGNMENT_FUNC_EXPR_FOUND,
)
except Exception as e:
- logger.debug(lg.JS_ASSIGNMENT_ARROW_QUERY_FAILED.format(error=e))
+ logger.debug(lg.JS_ASSIGNMENT_ARROW_QUERY_FAILED, error=e)
def _process_direct_arrow_functions(
self,
@@ -498,6 +506,9 @@ def _register_arrow_function(
function_node: ASTNode,
log_message: str,
) -> None:
+ function_qn = self.function_registry.register_unique_qn(
+ function_qn, function_node.start_point[0] + 1
+ )
function_props: PropertyDict = {
cs.KEY_QUALIFIED_NAME: function_qn,
cs.KEY_NAME: function_name,
@@ -506,9 +517,7 @@ def _register_arrow_function(
cs.KEY_DOCSTRING: self._get_docstring(function_node),
}
- logger.debug(
- log_message.format(function_name=function_name, function_qn=function_qn)
- )
+ logger.debug(log_message, function_name=function_name, function_qn=function_qn)
self.ingestor.ensure_node_batch(cs.NodeLabel.FUNCTION, function_props)
self.function_registry[function_qn] = NodeType.FUNCTION
self.simple_name_lookup[function_name].add(function_qn)
diff --git a/codebase_rag/parsers/js_ts/module_system.py b/codebase_rag/parsers/js_ts/module_system.py
index 436603575..c41296502 100644
--- a/codebase_rag/parsers/js_ts/module_system.py
+++ b/codebase_rag/parsers/js_ts/module_system.py
@@ -6,15 +6,17 @@
from typing import TYPE_CHECKING
from loguru import logger
-from tree_sitter import Query, QueryCursor
+from tree_sitter import QueryCursor
from ... import constants as cs
from ... import logs as ls
from ...types_defs import ASTNode
from ..utils import (
+ get_cached_query,
ingest_exported_function,
safe_decode_text,
safe_decode_with_fallback,
+ sorted_captures,
)
from .utils import get_js_ts_language_obj
@@ -29,6 +31,7 @@
class JsTsModuleSystemMixin:
+ __slots__ = ("_processed_imports",)
ingestor: IngestorProtocol
repo_path: Path
project_name: str
@@ -59,9 +62,9 @@ def _ingest_missing_import_patterns(
try:
try:
- query = Query(language_obj, cs.JS_COMMONJS_DESTRUCTURE_QUERY)
+ query = get_cached_query(language_obj, cs.JS_COMMONJS_DESTRUCTURE_QUERY)
cursor = QueryCursor(query)
- captures = cursor.captures(root_node)
+ captures = sorted_captures(cursor, root_node)
variable_declarators = captures.get(cs.CAPTURE_VARIABLE_DECLARATOR, [])
@@ -71,10 +74,10 @@ def _ingest_missing_import_patterns(
)
except Exception as e:
- logger.debug(ls.JS_COMMONJS_DESTRUCTURE_FAILED.format(error=e))
+ logger.debug(ls.JS_COMMONJS_DESTRUCTURE_FAILED, error=e)
except Exception as e:
- logger.debug(ls.JS_MISSING_IMPORT_PATTERNS_FAILED.format(error=e))
+ logger.debug(ls.JS_MISSING_IMPORT_PATTERNS_FAILED, error=e)
def _extract_require_module_name(self, declarator: ASTNode) -> str | None:
name_node = declarator.child_by_field_name(cs.FIELD_NAME)
@@ -148,7 +151,7 @@ def _process_variable_declarator_for_commonjs(
self._process_destructured_child(child, module_name, module_qn)
except Exception as e:
- logger.debug(ls.JS_COMMONJS_VAR_DECLARATOR_FAILED.format(error=e))
+ logger.debug(ls.JS_COMMONJS_VAR_DECLARATOR_FAILED, error=e)
def _process_commonjs_import(
self, imported_name: str, module_name: str, module_qn: str
@@ -179,20 +182,17 @@ def _process_commonjs_import(
)
logger.debug(
- ls.JS_MISSING_IMPORT_PATTERN.format(
- module_qn=module_qn,
- imported_name=imported_name,
- resolved_source_module=resolved_source_module,
- )
+ ls.JS_MISSING_IMPORT_PATTERN,
+ module_qn=module_qn,
+ imported_name=imported_name,
+ resolved_source_module=resolved_source_module,
)
self._processed_imports.add(import_key)
except Exception as e:
logger.debug(
- ls.JS_COMMONJS_IMPORT_FAILED.format(
- imported_name=imported_name, error=e
- )
+ ls.JS_COMMONJS_IMPORT_FAILED, imported_name=imported_name, error=e
)
def _ingest_export_function(
@@ -282,9 +282,8 @@ def _ingest_commonjs_exports(
for query_text in query_texts:
try:
- captures = QueryCursor(Query(language_obj, query_text)).captures(
- root_node
- )
+ cursor = QueryCursor(get_cached_query(language_obj, query_text))
+ captures = sorted_captures(cursor, root_node)
self._process_exports_pattern(
captures.get(cs.CAPTURE_EXPORTS_OBJ, []),
@@ -302,7 +301,7 @@ def _ingest_commonjs_exports(
)
except Exception as e:
- logger.debug(ls.JS_COMMONJS_EXPORTS_QUERY_FAILED.format(error=e))
+ logger.debug(ls.JS_COMMONJS_EXPORTS_QUERY_FAILED, error=e)
def _ingest_es6_exports(
self,
@@ -320,9 +319,9 @@ def _ingest_es6_exports(
]:
try:
cleaned_query = textwrap.dedent(query_text).strip()
- query = Query(lang_query, cleaned_query)
+ query = get_cached_query(lang_query, cleaned_query)
cursor = QueryCursor(query)
- captures = cursor.captures(root_node)
+ captures = sorted_captures(cursor, root_node)
export_names = captures.get(cs.CAPTURE_EXPORT_NAME, [])
export_functions = captures.get(cs.CAPTURE_EXPORT_FUNCTION, [])
@@ -365,7 +364,7 @@ def _ingest_es6_exports(
)
except Exception as e:
- logger.debug(ls.JS_ES6_EXPORTS_QUERY_FAILED.format(error=e))
+ logger.debug(ls.JS_ES6_EXPORTS_QUERY_FAILED, error=e)
except Exception as e:
- logger.debug(ls.JS_ES6_EXPORTS_DETECT_FAILED.format(error=e))
+ logger.debug(ls.JS_ES6_EXPORTS_DETECT_FAILED, error=e)
diff --git a/codebase_rag/parsers/js_ts/type_inference.py b/codebase_rag/parsers/js_ts/type_inference.py
index e4930e365..590beb44e 100644
--- a/codebase_rag/parsers/js_ts/type_inference.py
+++ b/codebase_rag/parsers/js_ts/type_inference.py
@@ -1,83 +1,149 @@
+from __future__ import annotations
+
from collections.abc import Callable
+from typing import TYPE_CHECKING
from loguru import logger
+from tree_sitter import Node, QueryCursor
from ... import constants as cs
from ... import logs as ls
from ...types_defs import ASTNode, FunctionRegistryTrieProtocol, NodeType
from ..import_processor import ImportProcessor
-from ..utils import safe_decode_text
+from ..utils import get_cached_query, safe_decode_text
from . import utils as ut
+if TYPE_CHECKING:
+ from ...types_defs import LanguageQueries
+
+_JS_DECLARATOR_QUERY = "(variable_declarator) @declarator"
+
class JsTypeInferenceEngine:
+ __slots__ = (
+ "import_processor",
+ "function_registry",
+ "project_name",
+ "_find_method_ast_node",
+ "_queries",
+ )
+
def __init__(
self,
import_processor: ImportProcessor,
function_registry: FunctionRegistryTrieProtocol,
project_name: str,
find_method_ast_node_func: Callable[[str], ASTNode | None],
+ queries: dict[cs.SupportedLanguage, LanguageQueries] | None = None,
):
self.import_processor = import_processor
self.function_registry = function_registry
self.project_name = project_name
self._find_method_ast_node = find_method_ast_node_func
+ self._queries = queries
+
+ def _get_declarators_via_query(
+ self, caller_node: ASTNode, language: cs.SupportedLanguage | None = None
+ ) -> list[Node] | None:
+ if self._queries is None:
+ return None
+ langs = (
+ [language]
+ if language is not None
+ else [cs.SupportedLanguage.JS, cs.SupportedLanguage.TS]
+ )
+ for lang in langs:
+ lang_queries = self._queries.get(lang)
+ if lang_queries and "language" in lang_queries:
+ try:
+ q = get_cached_query(lang_queries["language"], _JS_DECLARATOR_QUERY)
+ cursor = QueryCursor(q)
+ captures = cursor.captures(caller_node)
+ return captures.get("declarator", [])
+ except Exception:
+ continue
+ return None
def build_local_variable_type_map(
- self, caller_node: ASTNode, module_qn: str
+ self,
+ caller_node: ASTNode,
+ module_qn: str,
+ language: cs.SupportedLanguage | None = None,
) -> dict[str, str]:
local_var_types: dict[str, str] = {}
-
- stack: list[ASTNode] = [caller_node]
-
declarator_count = 0
- while stack:
- current = stack.pop()
-
- if current.type == cs.TS_VARIABLE_DECLARATOR:
+ declarator_nodes = self._get_declarators_via_query(caller_node, language)
+ if declarator_nodes is not None:
+ for current in declarator_nodes:
declarator_count += 1
name_node = current.child_by_field_name("name")
value_node = current.child_by_field_name("value")
-
if name_node and value_node:
var_name_text = name_node.text
if var_name_text:
var_name = safe_decode_text(name_node)
if var_name is not None:
logger.debug(
- ls.JS_VAR_DECLARATOR_FOUND.format(
- var_name=var_name, module_qn=module_qn
- )
+ ls.JS_VAR_DECLARATOR_FOUND,
+ var_name=var_name,
+ module_qn=module_qn,
)
-
if var_type := self._infer_js_variable_type_from_value(
value_node, module_qn
):
local_var_types[var_name] = var_type
logger.debug(
- ls.JS_VAR_INFERRED.format(
- var_name=var_name, var_type=var_type
- )
+ ls.JS_VAR_INFERRED,
+ var_name=var_name,
+ var_type=var_type,
)
else:
+ logger.debug(ls.JS_VAR_INFER_FAILED, var_name=var_name)
+ else:
+ stack: list[ASTNode] = [caller_node]
+ while stack:
+ current = stack.pop()
+ if current.type == cs.TS_VARIABLE_DECLARATOR:
+ declarator_count += 1
+ name_node = current.child_by_field_name("name")
+ value_node = current.child_by_field_name("value")
+ if name_node and value_node:
+ var_name_text = name_node.text
+ if var_name_text:
+ var_name = safe_decode_text(name_node)
+ if var_name is not None:
logger.debug(
- ls.JS_VAR_INFER_FAILED.format(var_name=var_name)
+ ls.JS_VAR_DECLARATOR_FOUND,
+ var_name=var_name,
+ module_qn=module_qn,
)
-
- stack.extend(reversed(current.children))
+ if var_type := self._infer_js_variable_type_from_value(
+ value_node, module_qn
+ ):
+ local_var_types[var_name] = var_type
+ logger.debug(
+ ls.JS_VAR_INFERRED,
+ var_name=var_name,
+ var_type=var_type,
+ )
+ else:
+ logger.debug(
+ ls.JS_VAR_INFER_FAILED, var_name=var_name
+ )
+ stack.extend(reversed(current.children))
logger.debug(
- ls.JS_VAR_TYPE_MAP_BUILT.format(
- count=len(local_var_types), declarator_count=declarator_count
- )
+ ls.JS_VAR_TYPE_MAP_BUILT,
+ count=len(local_var_types),
+ declarator_count=declarator_count,
)
return local_var_types
def _infer_js_variable_type_from_value(
self, value_node: ASTNode, module_qn: str
) -> str | None:
- logger.debug(ls.JS_INFER_VALUE_NODE.format(node_type=value_node.type))
+ logger.debug(ls.JS_INFER_VALUE_NODE, node_type=value_node.type)
if value_node.type == cs.TS_NEW_EXPRESSION:
if class_name := ut.extract_constructor_name(value_node):
@@ -87,28 +153,23 @@ def _infer_js_variable_type_from_value(
elif value_node.type == cs.TS_CALL_EXPRESSION:
func_node = value_node.child_by_field_name("function")
func_type = func_node.type if func_node else cs.STR_NONE
- logger.debug(ls.JS_CALL_EXPR_FUNC_NODE.format(func_type=func_type))
+ logger.debug(ls.JS_CALL_EXPR_FUNC_NODE, func_type=func_type)
if func_node and func_node.type == cs.TS_MEMBER_EXPRESSION:
method_call_text = ut.extract_method_call(func_node)
- logger.debug(
- ls.JS_EXTRACTED_METHOD_CALL.format(method_call=method_call_text)
- )
+ logger.debug(ls.JS_EXTRACTED_METHOD_CALL, method_call=method_call_text)
if method_call_text:
if inferred_type := self._infer_js_method_return_type(
method_call_text, module_qn
):
logger.debug(
- ls.JS_TYPE_INFERRED.format(
- method_call=method_call_text,
- inferred_type=inferred_type,
- )
+ ls.JS_TYPE_INFERRED,
+ method_call=method_call_text,
+ inferred_type=inferred_type,
)
return inferred_type
logger.debug(
- ls.JS_RETURN_TYPE_INFER_FAILED.format(
- method_call=method_call_text
- )
+ ls.JS_RETURN_TYPE_INFER_FAILED, method_call=method_call_text
)
elif func_node and func_node.type == cs.TS_IDENTIFIER:
@@ -116,7 +177,7 @@ def _infer_js_variable_type_from_value(
if func_name:
return safe_decode_text(func_node)
- logger.debug(ls.JS_NO_PATTERN_MATCHED.format(node_type=value_node.type))
+ logger.debug(ls.JS_NO_PATTERN_MATCHED, node_type=value_node.type)
return None
def _infer_js_method_return_type(
@@ -124,7 +185,7 @@ def _infer_js_method_return_type(
) -> str | None:
parts = method_call.split(cs.SEPARATOR_DOT)
if len(parts) != 2:
- logger.debug(ls.JS_METHOD_CALL_INVALID.format(method_call=method_call))
+ logger.debug(ls.JS_METHOD_CALL_INVALID, method_call=method_call)
return None
class_name, method_name = parts
@@ -132,27 +193,23 @@ def _infer_js_method_return_type(
class_qn = self._resolve_js_class_name(class_name, module_qn)
if not class_qn:
logger.debug(
- ls.JS_CLASS_RESOLVE_FAILED.format(
- class_name=class_name, module_qn=module_qn
- )
+ ls.JS_CLASS_RESOLVE_FAILED, class_name=class_name, module_qn=module_qn
)
return None
- logger.debug(
- ls.JS_CLASS_RESOLVED.format(class_name=class_name, class_qn=class_qn)
- )
+ logger.debug(ls.JS_CLASS_RESOLVED, class_name=class_name, class_qn=class_qn)
method_qn = f"{class_qn}{cs.SEPARATOR_DOT}{method_name}"
- logger.debug(ls.JS_LOOKING_FOR_METHOD.format(method_qn=method_qn))
+ logger.debug(ls.JS_LOOKING_FOR_METHOD, method_qn=method_qn)
method_node = self._find_method_ast_node(method_qn)
if not method_node:
- logger.debug(ls.JS_METHOD_AST_NOT_FOUND.format(method_qn=method_qn))
+ logger.debug(ls.JS_METHOD_AST_NOT_FOUND, method_qn=method_qn)
return None
return_type = self._analyze_return_statements(method_node, method_qn)
logger.debug(
- ls.JS_RETURN_ANALYZED.format(method_qn=method_qn, return_type=return_type)
+ ls.JS_RETURN_ANALYZED, method_qn=method_qn, return_type=return_type
)
return return_type
@@ -180,11 +237,20 @@ def _resolve_js_class_name(self, class_name: str, module_qn: str) -> str | None:
return None
+ def _get_language_obj(self) -> object | None:
+ if self._queries is None:
+ return None
+ for lang in (cs.SupportedLanguage.JS, cs.SupportedLanguage.TS):
+ lang_queries = self._queries.get(lang)
+ if lang_queries and "language" in lang_queries:
+ return lang_queries["language"]
+ return None
+
def _analyze_return_statements(
self, method_node: ASTNode, method_qn: str
) -> str | None:
return_nodes: list[ASTNode] = []
- ut.find_return_statements(method_node, return_nodes)
+ ut.find_return_statements(method_node, return_nodes, self._get_language_obj())
for return_node in return_nodes:
for child in return_node.children:
diff --git a/codebase_rag/parsers/js_ts/utils.py b/codebase_rag/parsers/js_ts/utils.py
index 5049afb0c..752660db7 100644
--- a/codebase_rag/parsers/js_ts/utils.py
+++ b/codebase_rag/parsers/js_ts/utils.py
@@ -1,9 +1,9 @@
from typing import TYPE_CHECKING
-from tree_sitter import Language, Node
+from tree_sitter import Language, Node, QueryCursor
from ... import constants as cs
-from ..utils import safe_decode_text
+from ..utils import get_cached_query, safe_decode_text
if TYPE_CHECKING:
from ...types_defs import LanguageQueries
@@ -53,11 +53,26 @@ def find_method_in_class_body(class_body_node: Node, method_name: str) -> Node |
return None
+_CLASS_BODY_CACHE: dict[tuple[int, str], Node | None] = {}
+_CLASS_BODY_CACHE_OWNER: int | None = None
+
+
def find_method_in_ast(
root_node: Node, class_name: str, method_name: str
) -> Node | None:
- stack: list[Node] = [root_node]
+ global _CLASS_BODY_CACHE_OWNER
+ root_id = id(root_node)
+ if _CLASS_BODY_CACHE_OWNER != root_id:
+ _CLASS_BODY_CACHE.clear()
+ _CLASS_BODY_CACHE_OWNER = root_id
+ cache_key = (root_id, class_name)
+ if cache_key in _CLASS_BODY_CACHE:
+ body_node = _CLASS_BODY_CACHE[cache_key]
+ if body_node is not None:
+ return find_method_in_class_body(body_node, method_name)
+ return None
+ stack: list[Node] = [root_node]
while stack:
current = stack.pop()
@@ -66,23 +81,38 @@ def find_method_in_ast(
if name_node and name_node.text:
found_class_name = safe_decode_text(name_node)
if found_class_name == class_name:
- if body_node := current.child_by_field_name(cs.FIELD_BODY):
+ body_node = current.child_by_field_name(cs.FIELD_BODY)
+ _CLASS_BODY_CACHE[cache_key] = body_node
+ if body_node:
return find_method_in_class_body(body_node, method_name)
+ return None
stack.extend(reversed(current.children))
+ _CLASS_BODY_CACHE[cache_key] = None
return None
-def find_return_statements(node: Node, return_nodes: list[Node]) -> None:
- stack: list[Node] = [node]
+_JS_RETURN_QUERY = "(return_statement) @return_stmt"
+
+def find_return_statements(
+ node: Node, return_nodes: list[Node], language_obj=None
+) -> None:
+ if language_obj is not None:
+ try:
+ q = get_cached_query(language_obj, _JS_RETURN_QUERY)
+ cursor = QueryCursor(q)
+ captures = cursor.captures(node)
+ return_nodes.extend(captures.get("return_stmt", []))
+ return
+ except Exception:
+ pass
+ stack: list[Node] = [node]
while stack:
current = stack.pop()
-
if current.type == cs.TS_RETURN_STATEMENT:
return_nodes.append(current)
-
stack.extend(reversed(current.children))
diff --git a/codebase_rag/parsers/lua/type_inference.py b/codebase_rag/parsers/lua/type_inference.py
index 99a5515ba..92b910881 100644
--- a/codebase_rag/parsers/lua/type_inference.py
+++ b/codebase_rag/parsers/lua/type_inference.py
@@ -14,6 +14,12 @@
class LuaTypeInferenceEngine:
+ __slots__ = (
+ "import_processor",
+ "function_registry",
+ "project_name",
+ )
+
def __init__(
self,
import_processor: ImportProcessor,
@@ -36,7 +42,7 @@ def build_local_variable_type_map(
self._process_variable_declaration(current, module_qn, local_var_types)
stack.extend(reversed(current.children))
- logger.debug(ls.LUA_VAR_TYPE_MAP_BUILT.format(count=len(local_var_types)))
+ logger.debug(ls.LUA_VAR_TYPE_MAP_BUILT, count=len(local_var_types))
return local_var_types
def _process_variable_declaration(
@@ -62,9 +68,7 @@ def _process_variable_declaration(
func_calls[i], module_qn
):
local_var_types[var_name] = var_type
- logger.debug(
- ls.LUA_VAR_INFERRED.format(var_name=var_name, var_type=var_type)
- )
+ logger.debug(ls.LUA_VAR_INFERRED, var_name=var_name, var_type=var_type)
def _extract_var_names(self, assignment: TreeSitterNodeProtocol) -> list[str]:
names: list[str] = []
@@ -110,11 +114,10 @@ def _infer_lua_variable_type_from_value(
class_name, module_qn
):
logger.debug(
- ls.LUA_TYPE_INFERENCE_RETURN.format(
- class_name=class_name,
- method_name=method_name,
- class_qn=class_qn,
- )
+ ls.LUA_TYPE_INFERENCE_RETURN,
+ class_name=class_name,
+ method_name=method_name,
+ class_qn=class_qn,
)
return class_qn
diff --git a/codebase_rag/parsers/py/ast_analyzer.py b/codebase_rag/parsers/py/ast_analyzer.py
index ec663db4f..9aea42fc2 100644
--- a/codebase_rag/parsers/py/ast_analyzer.py
+++ b/codebase_rag/parsers/py/ast_analyzer.py
@@ -10,7 +10,14 @@
from ... import logs as lg
from ...types_defs import LanguageQueries
from ..js_ts.utils import find_method_in_ast as find_js_method_in_ast
-from ..utils import safe_decode_text
+from ..utils import get_cached_query, safe_decode_text, sorted_captures
+
+_PY_TRAVERSE_QUERY = (
+ f"({cs.TS_PY_ASSIGNMENT}) @assignment "
+ f"({cs.TS_PY_LIST_COMPREHENSION}) @comprehension "
+ f"({cs.TS_PY_FOR_STATEMENT}) @for_stmt "
+ f"({cs.TS_PY_RETURN_STATEMENT}) @return_stmt"
+)
if TYPE_CHECKING:
from collections.abc import Callable
@@ -45,6 +52,7 @@ def _infer_instance_variable_types_from_assignments(
class PythonAstAnalyzerMixin(_AstBase):
+ __slots__ = ()
queries: dict[cs.SupportedLanguage, LanguageQueries]
module_qn_to_file_path: dict[str, Path]
ast_cache: ASTCacheProtocol
@@ -72,6 +80,8 @@ def _infer_method_call_return_type(
@abstractmethod
def _find_class_in_scope(self, class_name: str, module_qn: str) -> str | None: ...
+ _return_stmt_cache: dict[int, list[Node]]
+
def _traverse_single_pass(
self, node: Node, local_var_types: dict[str, str], module_qn: str
) -> None:
@@ -79,19 +89,35 @@ def _traverse_single_pass(
comprehensions: list[Node] = []
for_statements: list[Node] = []
- stack: list[Node] = [node]
- while stack:
- current = stack.pop()
- node_type = current.type
-
- if node_type == cs.TS_PY_ASSIGNMENT:
- assignments.append(current)
- elif node_type == cs.TS_PY_LIST_COMPREHENSION:
- comprehensions.append(current)
- elif node_type == cs.TS_PY_FOR_STATEMENT:
- for_statements.append(current)
-
- stack.extend(reversed(current.children))
+ py_lang_queries = self.queries.get(cs.SupportedLanguage.PYTHON)
+ py_lang_obj = py_lang_queries["language"] if py_lang_queries else None
+ if py_lang_obj is not None:
+ try:
+ q = get_cached_query(py_lang_obj, _PY_TRAVERSE_QUERY)
+ cursor = QueryCursor(q)
+ captures = cursor.captures(node)
+ assignments = captures.get("assignment", [])
+ comprehensions = captures.get("comprehension", [])
+ for_statements = captures.get("for_stmt", [])
+ if return_stmts := captures.get("return_stmt"):
+ self._return_stmt_cache[id(node)] = return_stmts
+ except Exception:
+ py_lang_obj = None
+
+ if py_lang_obj is None:
+ stack: list[Node] = [node]
+ while stack:
+ current = stack.pop()
+ node_type = current.type
+
+ if node_type == cs.TS_PY_ASSIGNMENT:
+ assignments.append(current)
+ elif node_type == cs.TS_PY_LIST_COMPREHENSION:
+ comprehensions.append(current)
+ elif node_type == cs.TS_PY_FOR_STATEMENT:
+ for_statements.append(current)
+
+ stack.extend(reversed(current.children))
for assignment in assignments:
self._process_assignment_simple(assignment, local_var_types, module_qn)
@@ -140,7 +166,7 @@ def _process_assignment_simple(
right_node, module_qn
):
local_var_types[var_name] = inferred_type
- logger.debug(lg.PY_TYPE_SIMPLE.format(var=var_name, type=inferred_type))
+ logger.debug(lg.PY_TYPE_SIMPLE, var=var_name, type=inferred_type)
def _process_assignment_complex(
self, assignment_node: Node, local_var_types: dict[str, str], module_qn: str
@@ -162,7 +188,7 @@ def _process_assignment_complex(
right_node, module_qn, local_var_types
):
local_var_types[var_name] = inferred_type
- logger.debug(lg.PY_TYPE_COMPLEX.format(var=var_name, type=inferred_type))
+ logger.debug(lg.PY_TYPE_COMPLEX, var=var_name, type=inferred_type)
def _extract_assignment_variable_name(self, node: Node) -> str | None:
if node.type != cs.TS_PY_IDENTIFIER or node.text is None:
@@ -202,6 +228,32 @@ def _find_method_in_ast(
case _:
return None
+ def _find_class_node(self, class_qn: str) -> Node | None:
+ # (H) Locate a class definition node from its qualified name so cross-class
+ # (H) attribute/property types can be read when resolving chained calls.
+ module_qn, _, class_name = class_qn.rpartition(cs.SEPARATOR_DOT)
+ if not module_qn:
+ return None
+ file_path = self.module_qn_to_file_path.get(module_qn)
+ if not file_path or file_path not in self.ast_cache:
+ return None
+ root_node, language = self.ast_cache[file_path]
+ if language != cs.SupportedLanguage.PYTHON:
+ return None
+ lang_queries = self.queries[cs.SupportedLanguage.PYTHON]
+ class_query = lang_queries[cs.QUERY_KEY_CLASSES]
+ if not class_query:
+ return None
+ cursor = QueryCursor(class_query)
+ captures = sorted_captures(cursor, root_node)
+ for class_node in captures.get(cs.QUERY_CAPTURE_CLASS, []):
+ if not isinstance(class_node, Node):
+ continue
+ name_node = class_node.child_by_field_name(cs.TS_FIELD_NAME)
+ if name_node and safe_decode_text(name_node) == class_name:
+ return class_node
+ return None
+
def _find_python_method_in_ast(
self, root_node: Node, class_name: str, method_name: str
) -> Node | None:
@@ -210,7 +262,7 @@ def _find_python_method_in_ast(
if not class_query:
return None
cursor = QueryCursor(class_query)
- captures = cursor.captures(root_node)
+ captures = sorted_captures(cursor, root_node)
method_query = lang_queries[cs.QUERY_KEY_FUNCTIONS]
if not method_query:
@@ -232,7 +284,7 @@ def _find_python_method_in_ast(
continue
method_cursor = QueryCursor(method_query)
- method_captures = method_cursor.captures(body_node)
+ method_captures = sorted_captures(method_cursor, body_node)
for method_node in method_captures.get(cs.QUERY_CAPTURE_FUNCTION, []):
if not isinstance(method_node, Node):
@@ -272,13 +324,26 @@ def _analyze_method_return_statements(
return None
def _find_return_statements(self, node: Node, return_nodes: list[Node]) -> None:
+ cached = self._return_stmt_cache.get(id(node))
+ if cached is not None:
+ return_nodes.extend(cached)
+ return
+ py_lang_queries = self.queries.get(cs.SupportedLanguage.PYTHON)
+ py_lang_obj = py_lang_queries["language"] if py_lang_queries else None
+ if py_lang_obj is not None:
+ try:
+ q = get_cached_query(py_lang_obj, cs.PY_RETURN_QUERY)
+ cursor = QueryCursor(q)
+ captures = cursor.captures(node)
+ return_nodes.extend(captures.get("return_stmt", []))
+ return
+ except Exception:
+ pass
stack: list[Node] = [node]
-
while stack:
current = stack.pop()
if current.type == cs.TS_PY_RETURN_STATEMENT:
return_nodes.append(current)
-
stack.extend(reversed(current.children))
def _analyze_return_expression(self, expr_node: Node, method_qn: str) -> str | None:
@@ -344,13 +409,11 @@ def _analyze_identifier_return(self, expr_node: Node, method_qn: str) -> str | N
local_vars = self.build_local_variable_type_map(method_node, module_qn)
if identifier in local_vars:
logger.debug(
- lg.PY_VAR_FROM_CONTEXT.format(
- var=identifier, type=local_vars[identifier]
- )
+ lg.PY_VAR_FROM_CONTEXT, var=identifier, type=local_vars[identifier]
)
return local_vars[identifier]
- logger.debug(lg.PY_VAR_CANNOT_INFER.format(var=identifier))
+ logger.debug(lg.PY_VAR_CANNOT_INFER, var=identifier)
return None
def _analyze_attribute_return(self, expr_node: Node, method_qn: str) -> str | None:
diff --git a/codebase_rag/parsers/py/expression_analyzer.py b/codebase_rag/parsers/py/expression_analyzer.py
index 81e0c28a2..73c159159 100644
--- a/codebase_rag/parsers/py/expression_analyzer.py
+++ b/codebase_rag/parsers/py/expression_analyzer.py
@@ -40,6 +40,7 @@ def _analyze_method_return_statements(
class PythonExpressionAnalyzerMixin(_ExprBase):
+ __slots__ = ()
import_processor: ImportProcessor
function_registry: FunctionRegistryTrieProtocol
simple_name_lookup: SimpleNameLookup
@@ -47,6 +48,7 @@ class PythonExpressionAnalyzerMixin(_ExprBase):
ast_cache: ASTCacheProtocol
_method_return_type_cache: dict[str, str | None]
+ _self_assignment_cache: dict[tuple[int, str], dict[str, str] | None]
def _infer_type_from_expression(self, node: Node, module_qn: str) -> str | None:
if node.type == cs.TS_PY_CALL:
@@ -243,7 +245,7 @@ def _infer_method_return_type(
return self._analyze_method_return_statements(method_node, method_qn)
return None
except Exception as e:
- logger.debug(lg.PY_INFER_RETURN_FAILED.format(method=method_call, error=e))
+ logger.debug(lg.PY_INFER_RETURN_FAILED, method=method_call, error=e)
return None
def _resolve_method_qualified_name(
@@ -305,11 +307,10 @@ def _resolve_class_method(
for qn in self.simple_name_lookup.get(class_name, []):
if result := self._try_resolve_method(qn, method_name):
logger.debug(
- lg.PY_RESOLVED_METHOD.format(
- class_name=class_name,
- method_name=method_name,
- method_qn=result,
- )
+ lg.PY_RESOLVED_METHOD,
+ class_name=class_name,
+ method_name=method_name,
+ method_qn=result,
)
return result
@@ -348,14 +349,22 @@ def _try_infer_from_self_assignments(
if language != cs.SupportedLanguage.PYTHON:
return None
- instance_vars: dict[str, str] = {}
- self._analyze_self_assignments(root_node, instance_vars, module_qn)
+ cache_key = (id(root_node), module_qn)
+ if cache_key in self._self_assignment_cache:
+ instance_vars = self._self_assignment_cache[cache_key]
+ else:
+ instance_vars = {}
+ self._analyze_self_assignments(root_node, instance_vars, module_qn)
+ self._self_assignment_cache[cache_key] = instance_vars or None
+
+ if not instance_vars:
+ return None
full_attr_name = f"{cs.PY_SELF_PREFIX}{attribute_name}"
return instance_vars.get(full_attr_name)
except Exception as e:
- logger.debug(lg.PY_INFER_ATTR_FAILED.format(attr=attribute_name, error=e))
+ logger.debug(lg.PY_INFER_ATTR_FAILED, attr=attribute_name, error=e)
return None
def _find_class_in_scope(self, class_name: str, module_qn: str) -> str | None:
diff --git a/codebase_rag/parsers/py/type_inference.py b/codebase_rag/parsers/py/type_inference.py
index 5908ee76a..ca9b9601a 100644
--- a/codebase_rag/parsers/py/type_inference.py
+++ b/codebase_rag/parsers/py/type_inference.py
@@ -30,6 +30,25 @@ class PythonTypeInferenceEngine(
PythonAstAnalyzerMixin,
PythonVariableAnalyzerMixin,
):
+ __slots__ = (
+ "import_processor",
+ "function_registry",
+ "repo_path",
+ "project_name",
+ "ast_cache",
+ "queries",
+ "module_qn_to_file_path",
+ "class_inheritance",
+ "simple_name_lookup",
+ "_js_type_inference_getter",
+ "_method_return_type_cache",
+ "_type_inference_in_progress",
+ "_available_classes_cache",
+ "_return_stmt_cache",
+ "_self_assignment_cache",
+ "_class_member_type_cache",
+ )
+
def __init__(
self,
import_processor: ImportProcessor,
@@ -56,6 +75,10 @@ def __init__(
self._method_return_type_cache: dict[str, str | None] = {}
self._type_inference_in_progress: set[str] = set()
+ self._available_classes_cache: dict[str, list[str]] = {}
+ self._return_stmt_cache: dict[int, list] = {}
+ self._self_assignment_cache: dict[tuple[int, str], dict[str, str] | None] = {}
+ self._class_member_type_cache: dict[str, dict[str, str]] = {}
def build_local_variable_type_map(
self, caller_node: Node, module_qn: str
@@ -66,8 +89,15 @@ def build_local_variable_type_map(
self._infer_parameter_types(caller_node, local_var_types, module_qn)
# (H) Single-pass traversal avoids O(5*N) multiple traversals for type inference.
self._traverse_single_pass(caller_node, local_var_types, module_qn)
+ self._infer_instance_attributes_from_init(
+ caller_node, local_var_types, module_qn
+ )
+ self._infer_property_return_types(caller_node, local_var_types, module_qn)
+ self._infer_class_annotation_types(caller_node, local_var_types, module_qn)
+ aliases = self._collect_local_aliases(caller_node)
+ self._expand_chained_attribute_types(local_var_types, module_qn, aliases)
except Exception as e:
- logger.debug(lg.PY_BUILD_VAR_MAP_FAILED.format(error=e))
+ logger.debug(lg.PY_BUILD_VAR_MAP_FAILED, error=e)
return local_var_types
diff --git a/codebase_rag/parsers/py/variable_analyzer.py b/codebase_rag/parsers/py/variable_analyzer.py
index 9a49f9a27..d0fe47220 100644
--- a/codebase_rag/parsers/py/variable_analyzer.py
+++ b/codebase_rag/parsers/py/variable_analyzer.py
@@ -3,12 +3,14 @@
from typing import TYPE_CHECKING, Protocol
from loguru import logger
+from tree_sitter import QueryCursor
from ... import constants as cs
from ... import logs as lg
from ...types_defs import ASTNode, FunctionRegistryTrieProtocol, NodeType
from ..import_processor import ImportProcessor
-from ..utils import safe_decode_text
+from ..utils import get_cached_query, safe_decode_text
+from .utils import resolve_class_name
if TYPE_CHECKING:
@@ -17,14 +19,20 @@ def _infer_type_from_expression(
self, node: ASTNode, module_qn: str
) -> str | None: ...
+ def _find_class_node(self, class_qn: str) -> ASTNode | None: ...
+
_VarBase: type = _VariableAnalyzerDeps
else:
_VarBase = object
class PythonVariableAnalyzerMixin(_VarBase):
+ __slots__ = ()
import_processor: ImportProcessor
function_registry: FunctionRegistryTrieProtocol
+ queries: dict[cs.SupportedLanguage, object]
+ _available_classes_cache: dict[str, list[str]]
+ _class_member_type_cache: dict[str, dict[str, str]]
def _infer_parameter_types(
self, caller_node: ASTNode, local_var_types: dict[str, str], module_qn: str
@@ -61,9 +69,7 @@ def _process_untyped_parameter(
):
return
local_var_types[param_name] = inferred_type
- logger.debug(
- lg.PY_PARAM_TYPE_INFERRED.format(param=param_name, type=inferred_type)
- )
+ logger.debug(lg.PY_PARAM_TYPE_INFERRED, param=param_name, type=inferred_type)
def _process_typed_parameter(
self, param: ASTNode, local_var_types: dict[str, str]
@@ -102,14 +108,14 @@ def _process_typed_default_parameter(
def _infer_type_from_parameter_name(
self, param_name: str, module_qn: str
) -> str | None:
- logger.debug(
- lg.PY_TYPE_INFER_ATTEMPT.format(param=param_name, module=module_qn)
- )
+ logger.debug(lg.PY_TYPE_INFER_ATTEMPT, param=param_name, module=module_qn)
available_class_names = self._collect_available_classes(module_qn)
- logger.debug(lg.PY_AVAILABLE_CLASSES.format(classes=available_class_names))
+ logger.debug(lg.PY_AVAILABLE_CLASSES, classes=available_class_names)
return self._find_best_class_match(param_name, available_class_names)
def _collect_available_classes(self, module_qn: str) -> list[str]:
+ if module_qn in self._available_classes_cache:
+ return self._available_classes_cache[module_qn]
available_class_names: list[str] = []
for qn, node_type in self.function_registry.find_with_prefix(module_qn):
if node_type != NodeType.CLASS:
@@ -118,6 +124,7 @@ def _collect_available_classes(self, module_qn: str) -> list[str]:
available_class_names.append(qn.split(cs.SEPARATOR_DOT)[-1])
if module_qn not in self.import_processor.import_mapping:
+ self._available_classes_cache[module_qn] = available_class_names
return available_class_names
for local_name, imported_qn in self.import_processor.import_mapping[
@@ -126,6 +133,7 @@ def _collect_available_classes(self, module_qn: str) -> list[str]:
if self.function_registry.get(imported_qn) == NodeType.CLASS:
available_class_names.append(local_name)
+ self._available_classes_cache[module_qn] = available_class_names
return available_class_names
def _find_best_class_match(
@@ -142,9 +150,7 @@ def _find_best_class_match(
best_match = class_name
logger.debug(
- lg.PY_BEST_MATCH.format(
- param=param_name, match=best_match, score=highest_score
- )
+ lg.PY_BEST_MATCH, param=param_name, match=best_match, score=highest_score
)
return best_match
@@ -195,9 +201,7 @@ def _infer_loop_var_from_iterable(
right_node, local_var_types, module_qn
):
local_var_types[loop_var] = element_type
- logger.debug(
- lg.PY_LOOP_VAR_INFERRED.format(var=loop_var, type=element_type)
- )
+ logger.debug(lg.PY_LOOP_VAR_INFERRED, var=loop_var, type=element_type)
def _infer_iterable_element_type(
self, iterable_node: ASTNode, local_var_types: dict[str, str], module_qn: str
@@ -250,27 +254,286 @@ def _process_self_assignment(
and (attr_name := left_text.decode(cs.ENCODING_UTF8)).startswith(
cs.PY_SELF_PREFIX
)
- and (
- assigned_type := self._infer_type_from_expression(right_node, module_qn)
- )
):
return
+ assigned_type = self._infer_type_from_expression(right_node, module_qn)
+ if not assigned_type and right_node.type == cs.TS_PY_IDENTIFIER:
+ # (H) self.x = param: a bare identifier carries the type of the matching
+ # (H) (already-seeded) parameter or local, so flow it onto the attribute.
+ ident = safe_decode_text(right_node)
+ assigned_type = local_var_types.get(ident) if ident else None
+ if not assigned_type:
+ return
local_var_types[attr_name] = assigned_type
- logger.debug(
- lg.PY_INSTANCE_VAR_INFERRED.format(attr=attr_name, type=assigned_type)
- )
+ logger.debug(lg.PY_INSTANCE_VAR_INFERRED, attr=attr_name, type=assigned_type)
def _analyze_self_assignments(
self, node: ASTNode, local_var_types: dict[str, str], module_qn: str
) -> None:
+ py_lang_queries = self.queries.get(cs.SupportedLanguage.PYTHON)
+ py_lang_obj = py_lang_queries["language"] if py_lang_queries else None
+ if py_lang_obj is not None:
+ try:
+ q = get_cached_query(py_lang_obj, cs.PY_ASSIGNMENT_QUERY)
+ cursor = QueryCursor(q)
+ captures = cursor.captures(node)
+ for assign_node in captures.get("assignment", []):
+ self._process_self_assignment(
+ assign_node, local_var_types, module_qn
+ )
+ return
+ except Exception:
+ pass
stack: list[ASTNode] = [node]
-
while stack:
current = stack.pop()
if current.type == cs.TS_PY_ASSIGNMENT:
self._process_self_assignment(current, local_var_types, module_qn)
stack.extend(reversed(current.children))
+ def _enclosing_class_node(self, node: ASTNode) -> ASTNode | None:
+ current = node.parent
+ while current is not None:
+ if current.type == cs.TS_PY_CLASS_DEFINITION:
+ return current
+ current = current.parent
+ return None
+
+ def _find_init_method_node(self, class_node: ASTNode) -> ASTNode | None:
+ body = class_node.child_by_field_name(cs.FIELD_BODY)
+ if body is None:
+ return None
+ for child in body.children:
+ if child.type == cs.TS_PY_DECORATED_DEFINITION:
+ func = next(
+ (
+ c
+ for c in child.children
+ if c.type == cs.TS_PY_FUNCTION_DEFINITION
+ ),
+ None,
+ )
+ elif child.type == cs.TS_PY_FUNCTION_DEFINITION:
+ func = child
+ else:
+ continue
+ if func is None:
+ continue
+ name_node = func.child_by_field_name(cs.FIELD_NAME)
+ if (
+ name_node
+ and (text := name_node.text)
+ and text.decode(cs.ENCODING_UTF8) == cs.PY_METHOD_INIT
+ ):
+ return func
+ return None
+
+ def _infer_instance_attributes_from_init(
+ self, caller_node: ASTNode, local_var_types: dict[str, str], module_qn: str
+ ) -> None:
+ # (H) Instance attributes are assigned in __init__ (self.x = T()), so a method
+ # (H) that only reads self.x has no local assignment to infer from. Scan the
+ # (H) enclosing class's __init__ and seed the attribute types, letting any
+ # (H) reassignment in the calling method itself take precedence (setdefault).
+ if (class_node := self._enclosing_class_node(caller_node)) is None:
+ return
+ init_node = self._find_init_method_node(class_node)
+ if init_node is None or init_node is caller_node:
+ return
+ init_types: dict[str, str] = {}
+ # (H) Seed __init__ parameter types first so self.x = param flows the
+ # (H) parameter annotation onto the attribute.
+ self._infer_parameter_types(init_node, init_types, module_qn)
+ self._analyze_self_assignments(init_node, init_types, module_qn)
+ for attr, attr_type in init_types.items():
+ if attr.startswith(cs.PY_SELF_PREFIX):
+ local_var_types.setdefault(attr, attr_type)
+
+ def _has_property_decorator(self, decorated_node: ASTNode) -> bool:
+ for child in decorated_node.children:
+ if child.type == cs.TS_PY_DECORATOR and (text := child.text):
+ tail = (
+ text.decode(cs.ENCODING_UTF8)
+ .lstrip(cs.DECORATOR_AT)
+ .split(cs.SEPARATOR_DOT)[-1]
+ )
+ if tail in cs.PROPERTY_DECORATORS:
+ return True
+ return False
+
+ def _infer_property_return_types(
+ self, caller_node: ASTNode, local_var_types: dict[str, str], module_qn: str
+ ) -> None:
+ # (H) self.prop where prop is an @property has the property's declared return
+ # (H) type, so a chained call self.prop.method() can resolve against the
+ # (H) returned class rather than an ambiguous same-named method elsewhere.
+ if (class_node := self._enclosing_class_node(caller_node)) is None:
+ return
+ self._collect_property_return_types(class_node, local_var_types)
+
+ def _collect_property_return_types(
+ self, class_node: ASTNode, out: dict[str, str]
+ ) -> None:
+ body = class_node.child_by_field_name(cs.FIELD_BODY)
+ if body is None:
+ return
+ for child in body.children:
+ if child.type != cs.TS_PY_DECORATED_DEFINITION:
+ continue
+ if not self._has_property_decorator(child):
+ continue
+ func = next(
+ (c for c in child.children if c.type == cs.TS_PY_FUNCTION_DEFINITION),
+ None,
+ )
+ if func is None:
+ continue
+ name_node = func.child_by_field_name(cs.FIELD_NAME)
+ return_node = func.child_by_field_name(cs.FIELD_RETURN_TYPE)
+ if not (
+ name_node
+ and (name_text := name_node.text)
+ and return_node
+ and (return_text := return_node.text)
+ ):
+ continue
+ # (H) The return_type field wraps a type node; only a bare class name (not
+ # (H) a union, subscripted generic, or string forward ref) seeds a type.
+ return_type = return_text.decode(cs.ENCODING_UTF8)
+ if return_type.isidentifier():
+ out.setdefault(
+ f"{cs.PY_SELF_PREFIX}{name_text.decode(cs.ENCODING_UTF8)}",
+ return_type,
+ )
+
+ def _infer_class_annotation_types(
+ self, caller_node: ASTNode, local_var_types: dict[str, str], module_qn: str
+ ) -> None:
+ # (H) A class-level annotation (_handler: LanguageHandler) declares the type of
+ # (H) an instance attribute even when it is assigned from a factory call whose
+ # (H) return type cannot be inferred, so seed self. from the annotation.
+ if (class_node := self._enclosing_class_node(caller_node)) is None:
+ return
+ self._collect_class_annotation_types(class_node, local_var_types)
+
+ def _collect_class_annotation_types(
+ self, class_node: ASTNode, out: dict[str, str]
+ ) -> None:
+ body = class_node.child_by_field_name(cs.FIELD_BODY)
+ if body is None:
+ return
+ for child in body.children:
+ if child.type != cs.TS_PY_EXPRESSION_STATEMENT:
+ continue
+ assignment = child.children[0] if child.children else None
+ if assignment is None or assignment.type != cs.TS_PY_ASSIGNMENT:
+ continue
+ left_node = assignment.child_by_field_name(cs.TS_FIELD_LEFT)
+ type_node = assignment.child_by_field_name(cs.TS_FIELD_TYPE)
+ if not (
+ left_node
+ and left_node.type == cs.TS_PY_IDENTIFIER
+ and type_node
+ and (name := safe_decode_text(left_node))
+ and (type_text := safe_decode_text(type_node))
+ and type_text.isidentifier()
+ ):
+ continue
+ out.setdefault(f"{cs.PY_SELF_PREFIX}{name}", type_text)
+
+ def _expand_chained_attribute_types(
+ self,
+ local_var_types: dict[str, str],
+ module_qn: str,
+ aliases: dict[str, str] | None = None,
+ max_depth: int = 4,
+ ) -> None:
+ # (H) A chained reference a.b.c needs the type of a.b (member b on a's class).
+ # (H) Each pass: (1) propagate local aliases (x = ref) from the referent's type,
+ # (H) then (2) for every typed ref, seed ref.member -> member type (full QN), so
+ # (H) deeper chains and aliases resolve on the next pass until a fixpoint.
+ aliases = aliases or {}
+ for _ in range(max_depth):
+ added = False
+ for local, referent in aliases.items():
+ if local not in local_var_types and (
+ referent_type := local_var_types.get(referent)
+ ):
+ local_var_types[local] = referent_type
+ added = True
+ for ref, type_name in list(local_var_types.items()):
+ class_qn = self._class_qn_of_type(type_name, module_qn)
+ if not class_qn:
+ continue
+ for member, member_type in self._class_member_types_by_qn(
+ class_qn
+ ).items():
+ key = f"{ref}{cs.SEPARATOR_DOT}{member}"
+ if key not in local_var_types:
+ local_var_types[key] = member_type
+ added = True
+ if not added:
+ break
+
+ def _collect_local_aliases(self, caller_node: ASTNode) -> dict[str, str]:
+ # (H) Record local-variable aliases (resolver = self._resolver) where the rhs is
+ # (H) a plain name/attribute reference, so its type can be propagated. Skip
+ # (H) nested scopes and any rhs that is a call/subscript/other expression.
+ aliases: dict[str, str] = {}
+ boundary = (cs.TS_PY_FUNCTION_DEFINITION, cs.TS_PY_CLASS_DEFINITION)
+ stack: list[ASTNode] = list(caller_node.children)
+ while stack:
+ node = stack.pop()
+ if node.type in boundary:
+ continue
+ if node.type == cs.TS_PY_ASSIGNMENT:
+ left = node.child_by_field_name(cs.TS_FIELD_LEFT)
+ right = node.child_by_field_name(cs.TS_FIELD_RIGHT)
+ if (
+ left is not None
+ and left.type == cs.TS_PY_IDENTIFIER
+ and right is not None
+ and right.type in (cs.TS_PY_IDENTIFIER, cs.TS_PY_ATTRIBUTE)
+ and (local := safe_decode_text(left))
+ and (referent := safe_decode_text(right))
+ and local not in aliases
+ ):
+ aliases[local] = referent
+ stack.extend(node.children)
+ return aliases
+
+ def _class_qn_of_type(self, type_name: str, module_qn: str) -> str | None:
+ if cs.SEPARATOR_DOT in type_name:
+ return type_name
+ return resolve_class_name(
+ type_name, module_qn, self.import_processor, self.function_registry
+ )
+
+ def _class_member_types_by_qn(self, class_qn: str) -> dict[str, str]:
+ if class_qn in self._class_member_type_cache:
+ return self._class_member_type_cache[class_qn]
+ members: dict[str, str] = {}
+ class_node = self._find_class_node(class_qn)
+ if class_node is not None:
+ class_module_qn = class_qn.rpartition(cs.SEPARATOR_DOT)[0]
+ raw: dict[str, str] = {}
+ self._collect_property_return_types(class_node, raw)
+ self._collect_class_annotation_types(class_node, raw)
+ if (init_node := self._find_init_method_node(class_node)) is not None:
+ init_types: dict[str, str] = {}
+ self._infer_parameter_types(init_node, init_types, class_module_qn)
+ self._analyze_self_assignments(init_node, init_types, class_module_qn)
+ for attr, attr_type in init_types.items():
+ raw.setdefault(attr, attr_type)
+ for attr, attr_type in raw.items():
+ if not attr.startswith(cs.PY_SELF_PREFIX):
+ continue
+ member = attr[len(cs.PY_SELF_PREFIX) :]
+ resolved = self._class_qn_of_type(attr_type, class_module_qn)
+ members[member] = resolved or attr_type
+ self._class_member_type_cache[class_qn] = members
+ return members
+
def _infer_variable_element_type(
self, var_name: str, local_var_types: dict[str, str], module_qn: str
) -> str | None:
diff --git a/codebase_rag/parsers/rs/utils.py b/codebase_rag/parsers/rs/utils.py
index 64cc84cf6..99743e758 100644
--- a/codebase_rag/parsers/rs/utils.py
+++ b/codebase_rag/parsers/rs/utils.py
@@ -137,12 +137,9 @@ def _process_scoped_use_list(
_process_use_tree(child, final_base, imports)
-def extract_impl_target(impl_node: Node) -> str | None:
- if impl_node.type != cs.TS_IMPL_ITEM:
- return None
-
+def _impl_field_type_name(impl_node: Node, field: str) -> str | None:
for i in range(impl_node.child_count):
- if impl_node.field_name_for_child(i) == cs.FIELD_TYPE:
+ if impl_node.field_name_for_child(i) == field:
type_node = impl_node.child(i)
if type_node is None:
continue
@@ -151,7 +148,7 @@ def extract_impl_target(impl_node: Node) -> str | None:
for child in type_node.children:
if child.type == cs.TS_TYPE_IDENTIFIER:
return safe_decode_text(child)
- case cs.TS_TYPE_IDENTIFIER:
+ case cs.TS_TYPE_IDENTIFIER | cs.TS_RS_PRIMITIVE_TYPE:
return safe_decode_text(type_node)
case cs.TS_RS_SCOPED_TYPE_IDENTIFIER:
for child in type_node.children:
@@ -162,6 +159,20 @@ def extract_impl_target(impl_node: Node) -> str | None:
return None
+def extract_impl_target(impl_node: Node) -> str | None:
+ if impl_node.type != cs.TS_IMPL_ITEM:
+ return None
+ return _impl_field_type_name(impl_node, cs.FIELD_TYPE)
+
+
+def extract_impl_trait(impl_node: Node) -> str | None:
+ # (H) The `trait` field of `impl Trait for Type` -> the implemented trait's
+ # (H) simple name (a trait impl means Type IMPLEMENTS Trait).
+ if impl_node.type != cs.TS_IMPL_ITEM:
+ return None
+ return _impl_field_type_name(impl_node, cs.FIELD_TRAIT)
+
+
def extract_use_imports(use_node: Node) -> dict[str, str]:
if use_node.type != cs.TS_USE_DECLARATION:
return {}
diff --git a/codebase_rag/parsers/stdlib_extractor.py b/codebase_rag/parsers/stdlib_extractor.py
index fbcbddd4c..52fc5d219 100644
--- a/codebase_rag/parsers/stdlib_extractor.py
+++ b/codebase_rag/parsers/stdlib_extractor.py
@@ -42,7 +42,7 @@ def _is_tool_available(tool_name: str) -> bool:
subprocess.CalledProcessError,
):
_EXTERNAL_TOOLS[tool_name] = False
- logger.debug(ls.IMP_TOOL_NOT_AVAILABLE.format(tool=tool_name))
+ logger.debug(ls.IMP_TOOL_NOT_AVAILABLE, tool=tool_name)
return False
@@ -77,9 +77,9 @@ def load_persistent_cache() -> None:
data = json.load(f)
_STDLIB_CACHE.update(data.get(cs.IMPORT_CACHE_KEY, {}))
_CACHE_TIMESTAMPS.update(data.get(cs.IMPORT_TIMESTAMPS_KEY, {}))
- logger.debug(ls.IMP_CACHE_LOADED.format(path=cache_file))
+ logger.debug(ls.IMP_CACHE_LOADED, path=cache_file)
except (json.JSONDecodeError, OSError) as e:
- logger.debug(ls.IMP_CACHE_LOAD_ERROR.format(error=e))
+ logger.debug(ls.IMP_CACHE_LOAD_ERROR, error=e)
def save_persistent_cache() -> None:
@@ -97,9 +97,9 @@ def save_persistent_cache() -> None:
f,
indent=2,
)
- logger.debug(ls.IMP_CACHE_SAVED.format(path=cache_file))
+ logger.debug(ls.IMP_CACHE_SAVED, path=cache_file)
except OSError as e:
- logger.debug(ls.IMP_CACHE_SAVE_ERROR.format(error=e))
+ logger.debug(ls.IMP_CACHE_SAVE_ERROR, error=e)
def flush_stdlib_cache() -> None:
@@ -115,7 +115,7 @@ def clear_stdlib_cache() -> None:
cache_file.unlink()
logger.debug(ls.IMP_CACHE_CLEARED)
except OSError as e:
- logger.debug(ls.IMP_CACHE_CLEAR_ERROR.format(error=e))
+ logger.debug(ls.IMP_CACHE_CLEAR_ERROR, error=e)
def get_stdlib_cache_stats() -> StdlibCacheStats:
@@ -130,6 +130,8 @@ def get_stdlib_cache_stats() -> StdlibCacheStats:
class StdlibExtractor:
+ __slots__ = ("function_registry", "repo_path", "project_name")
+
def __init__(
self,
function_registry: FunctionRegistryTrieProtocol | None = None,
@@ -248,7 +250,7 @@ def _resolve_python_entity_module_path(
result = (
cs.SEPARATOR_DOT.join(parts[:-1])
- if entity_name[0].isupper()
+ if entity_name[:1].isupper()
else full_qualified_name
)
_cache_stdlib_result(cs.SupportedLanguage.PYTHON, full_qualified_name, result)
@@ -330,15 +332,16 @@ def _resolve_js_entity_module_path(
):
pass
- result = (
- cs.SEPARATOR_DOT.join(parts[:-1])
- if entity_name[0].isupper()
- else full_qualified_name
- )
+ result = cs.SEPARATOR_DOT.join(parts[:-1])
_cache_stdlib_result(cs.SupportedLanguage.JS, full_qualified_name, result)
return result
def _extract_go_stdlib_path(self, full_qualified_name: str) -> str:
+ if cached := _get_cached_stdlib_result(
+ cs.SupportedLanguage.GO, full_qualified_name
+ ):
+ return cached
+
parts = full_qualified_name.split(cs.SEPARATOR_SLASH)
if len(parts) >= 2:
try:
@@ -453,6 +456,11 @@ def _extract_go_stdlib_path(self, full_qualified_name: str) -> str:
if proc.returncode == 0:
data = json.loads(stdout.strip())
if data[cs.JSON_KEY_HAS_ENTITY]:
+ _cache_stdlib_result(
+ cs.SupportedLanguage.GO,
+ full_qualified_name,
+ package_path,
+ )
return package_path
except (
@@ -464,219 +472,112 @@ def _extract_go_stdlib_path(self, full_qualified_name: str) -> str:
pass
entity_name = parts[-1]
- if entity_name[0].isupper():
- return cs.SEPARATOR_SLASH.join(parts[:-1])
+ if entity_name[:1].isupper():
+ result = cs.SEPARATOR_SLASH.join(parts[:-1])
+ _cache_stdlib_result(
+ cs.SupportedLanguage.GO, full_qualified_name, result
+ )
+ return result
+ _cache_stdlib_result(
+ cs.SupportedLanguage.GO, full_qualified_name, full_qualified_name
+ )
return full_qualified_name
def _extract_rust_stdlib_path(self, full_qualified_name: str) -> str:
+ if cached := _get_cached_stdlib_result(
+ cs.SupportedLanguage.RUST, full_qualified_name
+ ):
+ return cached
+
parts = full_qualified_name.split(cs.SEPARATOR_DOUBLE_COLON)
if len(parts) >= 2:
entity_name = parts[-1]
if (
- entity_name[0].isupper()
+ entity_name[:1].isupper()
or entity_name.isupper()
or (cs.CHAR_UNDERSCORE not in entity_name and entity_name.islower())
):
- return cs.SEPARATOR_DOUBLE_COLON.join(parts[:-1])
+ result = cs.SEPARATOR_DOUBLE_COLON.join(parts[:-1])
+ _cache_stdlib_result(
+ cs.SupportedLanguage.RUST, full_qualified_name, result
+ )
+ return result
+ _cache_stdlib_result(
+ cs.SupportedLanguage.RUST, full_qualified_name, full_qualified_name
+ )
return full_qualified_name
def _extract_cpp_stdlib_path(self, full_qualified_name: str) -> str:
+ if cached := _get_cached_stdlib_result(
+ cs.SupportedLanguage.CPP, full_qualified_name
+ ):
+ return cached
+
parts = full_qualified_name.split(cs.SEPARATOR_DOUBLE_COLON)
if len(parts) >= 2:
namespace = parts[0]
if namespace == cs.CPP_STD_NAMESPACE:
entity_name = parts[-1]
-
- try:
- import os
- import subprocess
- import tempfile
-
- with tempfile.NamedTemporaryFile(
- mode="w", suffix=".txt", delete=False
- ) as f:
- f.write(entity_name)
- entity_file = f.name
-
- try:
- cpp_template_program = f"""
-#include
-#include
-#include
-
-int main() {{
- std::ifstream file("{entity_file}");
- std::string entity_name;
- std::getline(file, entity_name);
- file.close();
-
- // This is a compile-time check strategy - we can't dynamically construct templates
- // Fall back to heuristic approach for safety
- std::cout << "heuristic_check" << std::endl;
- return 0;
-}}
- """
-
- subprocess.run(
- ["g++", "-std=c++17", "-x", "c++", "-", "-o", "/dev/null"],
- check=False,
- input=cpp_template_program,
- capture_output=True,
- text=True,
- timeout=5,
- )
-
- finally:
- os.unlink(entity_file)
-
- except (
- subprocess.TimeoutExpired,
- subprocess.CalledProcessError,
- OSError,
- ):
- pass
-
- entity_name = parts[-1]
if (
- entity_name[0].isupper()
+ entity_name[:1].isupper()
or entity_name.startswith(cs.CPP_PREFIX_IS)
or entity_name.startswith(cs.CPP_PREFIX_HAS)
or entity_name in cs.CPP_STDLIB_ENTITIES
):
- return cs.SEPARATOR_DOUBLE_COLON.join(parts[:-1])
+ result = cs.SEPARATOR_DOUBLE_COLON.join(parts[:-1])
+ _cache_stdlib_result(
+ cs.SupportedLanguage.CPP, full_qualified_name, result
+ )
+ return result
+ _cache_stdlib_result(
+ cs.SupportedLanguage.CPP, full_qualified_name, full_qualified_name
+ )
return full_qualified_name
def _extract_java_stdlib_path(self, full_qualified_name: str) -> str:
+ cached_result = _get_cached_stdlib_result(
+ cs.SupportedLanguage.JAVA, full_qualified_name
+ )
+ if cached_result is not None:
+ return cached_result
+
parts = full_qualified_name.split(cs.SEPARATOR_DOT)
if len(parts) >= 2:
- try:
- import os
- import subprocess
- import tempfile
-
- package_name = cs.SEPARATOR_DOT.join(parts[:-1])
- entity_name = parts[-1]
-
- java_program = """
-import java.lang.reflect.*;
-
-public class StdlibCheck {
- public static void main(String[] args) {
- if (args.length < 2) {
- System.out.println("{\\"hasEntity\\": false}");
- return;
- }
-
- String packageName = args[0];
- String entityName = args[1];
-
- try {
- Class clazz = Class.forName(packageName + "." + entityName);
- System.out.println("{\\"hasEntity\\": true, \\"entityType\\": \\"class\\"}");
- } catch (ClassNotFoundException e) {
- // Try as method or field in parent package
- try {
- Class packageClass = Class.forName(packageName);
- Method[] methods = packageClass.getMethods();
- Field[] fields = packageClass.getFields();
-
- boolean foundMethod = false;
- for (Method method : methods) {
- if (method.getName().equals(entityName)) {
- foundMethod = true;
- break;
- }
- }
-
- boolean foundField = false;
- for (Field field : fields) {
- if (field.getName().equals(entityName)) {
- foundField = true;
- break;
- }
- }
-
- if (foundMethod || foundField) {
- System.out.println("{\\"hasEntity\\": true, \\"entityType\\": \\"member\\"}");
- } else {
- System.out.println("{\\"hasEntity\\": false}");
- }
- } catch (Exception ex) {
- System.out.println("{\\"hasEntity\\": false}");
- }
- }
- }
-}
- """
-
- with tempfile.NamedTemporaryFile(
- mode="w", suffix=".java", delete=False
- ) as f:
- f.write(java_program)
- java_file = f.name
-
- try:
- compile_result = subprocess.run(
- ["javac", java_file],
- check=False,
- capture_output=True,
- text=True,
- timeout=10,
- )
-
- if compile_result.returncode == 0:
- class_name = os.path.splitext(os.path.basename(java_file))[0]
- run_result = subprocess.run(
- [
- "java",
- "-cp",
- os.path.dirname(java_file),
- class_name,
- package_name,
- entity_name,
- ],
- check=False,
- capture_output=True,
- text=True,
- timeout=10,
- )
-
- if run_result.returncode == 0:
- data = json.loads(run_result.stdout.strip())
- if data.get(cs.JSON_KEY_HAS_ENTITY):
- return cs.SEPARATOR_DOT.join(parts[:-1])
-
- finally:
- for ext in (cs.EXT_JAVA, cs.EXT_CLASS):
- temp_file = os.path.splitext(java_file)[0] + ext
- try:
- os.unlink(temp_file)
- except OSError:
- pass
-
- except (
- subprocess.TimeoutExpired,
- subprocess.CalledProcessError,
- json.JSONDecodeError,
- OSError,
- ):
- pass
-
entity_name = parts[-1]
- if (
- entity_name[0].isupper()
+ is_class_entity = (
+ entity_name[:1].isupper()
or entity_name.endswith(cs.JAVA_SUFFIX_EXCEPTION)
or entity_name.endswith(cs.JAVA_SUFFIX_ERROR)
or entity_name.endswith(cs.JAVA_SUFFIX_INTERFACE)
or entity_name.endswith(cs.JAVA_SUFFIX_BUILDER)
or entity_name in cs.JAVA_STDLIB_CLASSES
- ):
- return cs.SEPARATOR_DOT.join(parts[:-1])
+ )
+
+ if full_qualified_name.startswith(cs.JAVA_STDLIB_PREFIXES):
+ result = (
+ cs.SEPARATOR_DOT.join(parts[:-1])
+ if is_class_entity
+ else full_qualified_name
+ )
+ _cache_stdlib_result(
+ cs.SupportedLanguage.JAVA, full_qualified_name, result
+ )
+ return result
+ if is_class_entity:
+ result = cs.SEPARATOR_DOT.join(parts[:-1])
+ _cache_stdlib_result(
+ cs.SupportedLanguage.JAVA, full_qualified_name, result
+ )
+ return result
+
+ _cache_stdlib_result(
+ cs.SupportedLanguage.JAVA, full_qualified_name, full_qualified_name
+ )
return full_qualified_name
def _extract_lua_stdlib_path(self, full_qualified_name: str) -> str:
@@ -750,7 +651,7 @@ def _extract_lua_stdlib_path(self, full_qualified_name: str) -> str:
pass
entity_name = parts[-1]
- if entity_name[0].isupper() or entity_name in cs.LUA_STDLIB_MODULES:
+ if entity_name[:1].isupper() or entity_name in cs.LUA_STDLIB_MODULES:
return cs.SEPARATOR_DOT.join(parts[:-1])
return full_qualified_name
@@ -759,7 +660,7 @@ def _extract_generic_stdlib_path(self, full_qualified_name: str) -> str:
parts = full_qualified_name.split(cs.SEPARATOR_DOT)
if len(parts) >= 2:
entity_name = parts[-1]
- if entity_name[0].isupper():
+ if entity_name[:1].isupper():
return cs.SEPARATOR_DOT.join(parts[:-1])
return full_qualified_name
diff --git a/codebase_rag/parsers/structure_processor.py b/codebase_rag/parsers/structure_processor.py
index 9b4065bd3..78b853773 100644
--- a/codebase_rag/parsers/structure_processor.py
+++ b/codebase_rag/parsers/structure_processor.py
@@ -6,10 +6,24 @@
from .. import logs
from ..services import IngestorProtocol
from ..types_defs import LanguageQueries, NodeIdentifier
-from ..utils.path_utils import should_skip_path
+from ..utils.path_utils import (
+ cached_relative_path,
+ cached_resolve_posix,
+ should_skip_path,
+)
class StructureProcessor:
+ __slots__ = (
+ "ingestor",
+ "repo_path",
+ "project_name",
+ "queries",
+ "structural_elements",
+ "unignore_paths",
+ "exclude_paths",
+ )
+
def __init__(
self,
ingestor: IngestorProtocol,
@@ -47,19 +61,18 @@ def identify_structure(self) -> None:
):
directories.add(path)
+ package_indicators: set[str] = set()
+ for lang_queries in self.queries.values():
+ lang_config = lang_queries[cs.QUERY_CONFIG]
+ package_indicators.update(lang_config.package_indicators)
+
for root in sorted(directories):
- relative_root = root.relative_to(self.repo_path)
+ relative_root = cached_relative_path(root, self.repo_path)
parent_rel_path = relative_root.parent
parent_container_qn = self.structural_elements.get(parent_rel_path)
is_package = False
- package_indicators: set[str] = set()
-
- for lang_queries in self.queries.values():
- lang_config = lang_queries[cs.QUERY_CONFIG]
- package_indicators.update(lang_config.package_indicators)
-
for indicator in package_indicators:
if (root / indicator).exists():
is_package = True
@@ -79,6 +92,7 @@ def identify_structure(self) -> None:
cs.KEY_QUALIFIED_NAME: package_qn,
cs.KEY_NAME: root.name,
cs.KEY_PATH: relative_root.as_posix(),
+ cs.KEY_ABSOLUTE_PATH: cached_resolve_posix(root),
},
)
parent_identifier = self._get_parent_identifier(
@@ -96,7 +110,11 @@ def identify_structure(self) -> None:
)
self.ingestor.ensure_node_batch(
cs.NodeLabel.FOLDER,
- {cs.KEY_PATH: relative_root.as_posix(), cs.KEY_NAME: root.name},
+ {
+ cs.KEY_PATH: relative_root.as_posix(),
+ cs.KEY_NAME: root.name,
+ cs.KEY_ABSOLUTE_PATH: cached_resolve_posix(root),
+ },
)
parent_identifier = self._get_parent_identifier(
parent_rel_path, parent_container_qn
@@ -108,8 +126,8 @@ def identify_structure(self) -> None:
)
def process_generic_file(self, file_path: Path, file_name: str) -> None:
- relative_filepath = file_path.relative_to(self.repo_path).as_posix()
- relative_root = file_path.parent.relative_to(self.repo_path)
+ relative_filepath = cached_relative_path(file_path, self.repo_path).as_posix()
+ relative_root = cached_relative_path(file_path.parent, self.repo_path)
parent_container_qn = self.structural_elements.get(relative_root)
parent_identifier = self._get_parent_identifier(
@@ -122,6 +140,7 @@ def process_generic_file(self, file_path: Path, file_name: str) -> None:
cs.KEY_PATH: relative_filepath,
cs.KEY_NAME: file_name,
cs.KEY_EXTENSION: file_path.suffix,
+ cs.KEY_ABSOLUTE_PATH: cached_resolve_posix(file_path),
},
)
diff --git a/codebase_rag/parsers/type_inference.py b/codebase_rag/parsers/type_inference.py
index 815e4af81..f4834c255 100644
--- a/codebase_rag/parsers/type_inference.py
+++ b/codebase_rag/parsers/type_inference.py
@@ -19,6 +19,22 @@
class TypeInferenceEngine:
+ __slots__ = (
+ "import_processor",
+ "function_registry",
+ "repo_path",
+ "project_name",
+ "ast_cache",
+ "queries",
+ "module_qn_to_file_path",
+ "class_inheritance",
+ "simple_name_lookup",
+ "_java_type_inference",
+ "_lua_type_inference",
+ "_js_type_inference",
+ "_python_type_inference",
+ )
+
def __init__(
self,
import_processor: ImportProcessor,
@@ -80,6 +96,7 @@ def js_type_inference(self) -> JsTypeInferenceEngine:
function_registry=self.function_registry,
project_name=self.project_name,
find_method_ast_node_func=self.python_type_inference._find_method_ast_node,
+ queries=self.queries,
)
return self._js_type_inference
@@ -110,7 +127,7 @@ def build_local_variable_type_map(
)
case cs.SupportedLanguage.JS | cs.SupportedLanguage.TS:
return self.js_type_inference.build_local_variable_type_map(
- caller_node, module_qn
+ caller_node, module_qn, language
)
case cs.SupportedLanguage.JAVA:
return self.java_type_inference.build_variable_type_map(
diff --git a/codebase_rag/parsers/utils.py b/codebase_rag/parsers/utils.py
index b164a5022..ce5e27288 100644
--- a/codebase_rag/parsers/utils.py
+++ b/codebase_rag/parsers/utils.py
@@ -2,6 +2,7 @@
from collections.abc import Callable
from functools import lru_cache
+from pathlib import Path
from typing import TYPE_CHECKING, NamedTuple
from loguru import logger
@@ -17,18 +18,59 @@
SimpleNameLookup,
TreeSitterNodeProtocol,
)
+from ..utils.path_utils import cached_relative_path, cached_resolve_posix
if TYPE_CHECKING:
from ..language_spec import LanguageSpec
from ..services import IngestorProtocol
from ..types_defs import FunctionRegistryTrieProtocol
+_QUERY_CACHE: dict[tuple[int, str], Query] = {}
+_QUERY_LAST: tuple[tuple[int, str], Query] | None = None
+
+
+def get_cached_query(language_obj, query_text: str) -> Query:
+ global _QUERY_LAST
+ key = (id(language_obj), query_text)
+ if _QUERY_LAST is not None and _QUERY_LAST[0] == key:
+ return _QUERY_LAST[1]
+ if key not in _QUERY_CACHE:
+ _QUERY_CACHE[key] = Query(language_obj, query_text)
+ result = _QUERY_CACHE[key]
+ _QUERY_LAST = (key, result)
+ return result
+
class FunctionCapturesResult(NamedTuple):
lang_config: LanguageSpec
captures: dict[str, list[ASTNode]]
+def sorted_captures(cursor: QueryCursor, node: ASTNode) -> dict[str, list[ASTNode]]:
+ # (H) tree-sitter v0.25 captures() returns nodes in non-deterministic order
+ # (H) across process invocations; sort by start_byte for reproducibility
+ raw = cursor.captures(node)
+ result: dict[str, list[ASTNode]] = {}
+ for name, nodes in raw.items():
+ if len(nodes) <= 1:
+ result[name] = nodes
+ else:
+ is_sorted = True
+ prev_byte = nodes[0].start_byte
+ for i in range(1, len(nodes)):
+ cur_byte = nodes[i].start_byte
+ if cur_byte < prev_byte:
+ is_sorted = False
+ break
+ prev_byte = cur_byte
+ result[name] = nodes if is_sorted else sorted(nodes, key=_start_byte_key)
+ return result
+
+
+def _start_byte_key(n: ASTNode) -> int:
+ return n.start_byte
+
+
def get_function_captures(
root_node: ASTNode,
language: cs.SupportedLanguage,
@@ -41,11 +83,11 @@ def get_function_captures(
return None
cursor = QueryCursor(query)
- captures = cursor.captures(root_node)
+ captures = sorted_captures(cursor, root_node)
return FunctionCapturesResult(lang_config, captures)
-@lru_cache(maxsize=10000)
+@lru_cache(maxsize=50000)
def _cached_decode_bytes(text_bytes: bytes) -> str:
return text_bytes.decode(cs.ENCODING_UTF8)
@@ -72,6 +114,102 @@ def contains_node(parent: ASTNode, target: ASTNode) -> bool:
)
+def _decorator_tail_names(decorators: list[str]) -> set[str]:
+ return {
+ decorator.lstrip(cs.DECORATOR_AT).split(cs.SEPARATOR_DOT)[-1]
+ for decorator in decorators
+ }
+
+
+def _is_property_decorator(decorators: list[str]) -> bool:
+ return bool(_decorator_tail_names(decorators) & cs.PROPERTY_DECORATORS)
+
+
+def _is_abstract_decorator(decorators: list[str]) -> bool:
+ return bool(_decorator_tail_names(decorators) & cs.ABSTRACT_DECORATORS)
+
+
+_PY_NAMED_PARAMETERS = frozenset(
+ {cs.TS_PY_DEFAULT_PARAMETER, cs.TS_PY_TYPED_DEFAULT_PARAMETER}
+)
+_PY_SCOPE_BOUNDARIES = frozenset(
+ {
+ cs.TS_PY_FUNCTION_DEFINITION,
+ cs.TS_PY_CLASS_DEFINITION,
+ cs.TS_PY_DECORATED_DEFINITION,
+ }
+)
+
+
+def _python_parameter_name(param_node: Node) -> str | None:
+ if param_node.type == cs.TS_PY_IDENTIFIER:
+ return safe_decode_text(param_node)
+ if param_node.type in _PY_NAMED_PARAMETERS:
+ name_node = param_node.child_by_field_name(cs.FIELD_NAME)
+ if name_node is not None and name_node.type == cs.TS_PY_IDENTIFIER:
+ return safe_decode_text(name_node)
+ return None
+ if param_node.type == cs.TS_PY_TYPED_PARAMETER:
+ for child in param_node.children:
+ if child.type == cs.TS_PY_IDENTIFIER:
+ return safe_decode_text(child)
+ return None
+
+
+def _python_invoked_parameter_names(body_node: Node, candidates: set[str]) -> set[str]:
+ invoked: set[str] = set()
+ stack = [body_node]
+ while stack:
+ node = stack.pop()
+ if node.type == cs.TS_PY_CALL:
+ fn = node.child_by_field_name(cs.FIELD_FUNCTION)
+ if (
+ fn is not None
+ and fn.type == cs.TS_PY_IDENTIFIER
+ and (name := safe_decode_text(fn)) in candidates
+ ):
+ invoked.add(name)
+ for child in node.children:
+ # (H) Nested def/class bodies rebind the param name, so do not let an
+ # (H) inner call to a same-named local masquerade as the outer param.
+ if child.type not in _PY_SCOPE_BOUNDARIES:
+ stack.append(child)
+ return invoked
+
+
+def python_parameter_names(func_node: Node) -> list[str]:
+ # (H) Ordered parameter names with a leading self/cls dropped, so positions line
+ # (H) up with how call-site arguments map to parameters for bound methods.
+ params_node = func_node.child_by_field_name(cs.FIELD_PARAMETERS)
+ if params_node is None:
+ return []
+ names: list[str] = []
+ for child in params_node.named_children:
+ if (name := _python_parameter_name(child)) is not None:
+ names.append(name)
+ if names and names[0] in (cs.PY_KEYWORD_SELF, cs.PY_KEYWORD_CLS):
+ names = names[1:]
+ return names
+
+
+def callable_parameter_indices(
+ func_node: Node, language: cs.SupportedLanguage | None
+) -> dict[str, int]:
+ # (H) Maps each parameter that is invoked as a call inside the function body
+ # (H) to its positional index in the call-site argument list (self/cls
+ # (H) dropped so the index lines up with how bound methods are invoked).
+ if language != cs.SupportedLanguage.PYTHON:
+ return {}
+ body_node = func_node.child_by_field_name(cs.FIELD_BODY)
+ if body_node is None or not (names := python_parameter_names(func_node)):
+ return {}
+
+ invoked = _python_invoked_parameter_names(body_node, set(names))
+ if not invoked:
+ return {}
+ return {name: index for index, name in enumerate(names) if name in invoked}
+
+
def ingest_method(
method_node: ASTNode,
container_qn: str,
@@ -83,6 +221,8 @@ def ingest_method(
language: cs.SupportedLanguage | None = None,
extract_decorators_func: Callable[[ASTNode], list[str]] | None = None,
method_qualified_name: str | None = None,
+ file_path: Path | None = None,
+ repo_path: Path | None = None,
) -> None:
if language == cs.SupportedLanguage.CPP:
from .cpp import utils as cpp_utils
@@ -98,6 +238,10 @@ def ingest_method(
method_name = text.decode(cs.ENCODING_UTF8)
method_qn = method_qualified_name or f"{container_qn}.{method_name}"
+ if language != cs.SupportedLanguage.CPP:
+ method_qn = function_registry.register_unique_qn(
+ method_qn, method_node.start_point[0] + 1
+ )
decorators = extract_decorators_func(method_node) if extract_decorators_func else []
@@ -109,14 +253,36 @@ def ingest_method(
cs.KEY_END_LINE: method_node.end_point[0] + 1,
cs.KEY_DOCSTRING: get_docstring_func(method_node),
}
+ if file_path is not None and repo_path is not None:
+ method_props[cs.KEY_PATH] = cached_relative_path(
+ file_path, repo_path
+ ).as_posix()
+ method_props[cs.KEY_ABSOLUTE_PATH] = cached_resolve_posix(file_path)
logger.info(logs.METHOD_FOUND.format(name=method_name, qn=method_qn))
ingestor.ensure_node_batch(cs.NodeLabel.METHOD, method_props)
function_registry[method_qn] = NodeType.METHOD
+ if _is_property_decorator(decorators):
+ function_registry.mark_property(method_qn)
+ if _is_abstract_decorator(decorators):
+ function_registry.mark_abstract(method_qn)
+ function_registry.mark_callable_params(
+ method_qn, callable_parameter_indices(method_node, language)
+ )
simple_name_lookup[method_name].add(method_qn)
+ # (H) The DEFINES_METHOD parent is matched in the graph by LABEL +
+ # (H) qualified_name, so it must carry the container's real node label. Callers
+ # (H) pass Class by default, but a trait/interface (Interface) or enum (Enum)
+ # (H) container would then never match, dropping the containment edge. Prefer
+ # (H) the label the container was actually registered with.
+ container_label = container_type
+ registered = function_registry.get(container_qn)
+ if registered is not None and registered != NodeType.METHOD:
+ container_label = cs.NodeLabel(registered.value)
+
ingestor.ensure_relationship_batch(
- (container_type, cs.KEY_QUALIFIED_NAME, container_qn),
+ (container_label, cs.KEY_QUALIFIED_NAME, container_qn),
cs.RelationshipType.DEFINES_METHOD,
(cs.NodeLabel.METHOD, cs.KEY_QUALIFIED_NAME, method_qn),
)
@@ -137,6 +303,9 @@ def ingest_exported_function(
return
function_qn = f"{module_qn}.{function_name}"
+ function_qn = function_registry.register_unique_qn(
+ function_qn, function_node.start_point[0] + 1
+ )
function_props = {
cs.KEY_QUALIFIED_NAME: function_qn,
@@ -161,8 +330,21 @@ def is_method_node(func_node: ASTNode, lang_config: LanguageSpec) -> bool:
if not isinstance(current, Node):
return False
- while current and current.type not in lang_config.module_node_types:
- if current.type in lang_config.class_node_types:
+ class_types = lang_config.class_node_types
+ func_types = lang_config.function_node_types
+ module_types = lang_config.module_node_types
+ body_field = cs.FIELD_BODY
+
+ while current is not None:
+ current_type = current.type
+ if current_type in module_types:
+ return False
+ if current_type in class_types:
return True
+ if (
+ current_type in func_types
+ and current.child_by_field_name(body_field) is not None
+ ):
+ return False
current = current.parent
return False
diff --git a/codebase_rag/prompts.py b/codebase_rag/prompts.py
index de5cce132..9eaae75b1 100644
--- a/codebase_rag/prompts.py
+++ b/codebase_rag/prompts.py
@@ -26,7 +26,6 @@ def extract_tool_names(tools: list["Tool"]) -> ToolNames:
"query_codebase_knowledge_graph", "query_codebase_knowledge_graph"
),
read_file=tool_map.get("read_file_content", "read_file_content"),
- analyze_document=tool_map.get("analyze_document", "analyze_document"),
semantic_search=tool_map.get("semantic_code_search", "semantic_code_search"),
create_file=tool_map.get("create_new_file", "create_new_file"),
edit_file=tool_map.get("replace_code_surgically", "replace_code_surgically"),
@@ -40,7 +39,37 @@ def extract_tool_names(tools: list["Tool"]) -> ToolNames:
- **Use `STARTS WITH` for Paths**: When matching paths, always use `STARTS WITH` for robustness (e.g., `WHERE n.path STARTS WITH 'workflows/src'`). Do not use `=`.
- **Use `ENDS WITH` for qualified_name**: The `qualified_name` property contains full paths like `'Project.folder.subfolder.ClassName'`. When users mention a class, function, or method by its short name (e.g., "VatManager"), use `ENDS WITH` to match: `WHERE c.qualified_name ENDS WITH '.VatManager'`. Do NOT use `{name: 'VatManager'}` equality matching.
- **Use `toLower()` for Searches**: For case-insensitive searching on string properties, use `toLower()`.
-- **Querying Lists**: To check if a list property (like `decorators`) contains an item, use the `ANY` or `IN` clause (e.g., `WHERE 'flow' IN n.decorators`)."""
+- **Querying Lists**: To check if a list property (like `decorators`) contains an item, use the `ANY` or `IN` clause (e.g., `WHERE 'flow' IN n.decorators`).
+- **NEVER use unbounded variable-length paths**: Patterns like `[:CALLS*]`, `[*]`, `[:CALLS*1..]` enumerate every path in the graph and exhaust memory. Always cap with an upper bound, e.g. `[:CALLS*1..6]`. If you genuinely need unbounded reachability, use a MAGE procedure (see Section 2b) instead of variable-length Cypher.
+
+**2b. Graph Algorithm Procedures (MAGE)**
+
+For algorithmic questions (longest/shortest paths, cycles, recursion clusters, centrality, communities, reachability), prefer calling a MAGE procedure over writing variable-length Cypher. Cypher path patterns enumerate all matches with no memoization, so they OOM on cyclic graphs; MAGE procedures run real graph algorithms in bounded memory.
+
+Use these read-only procedures (call them with `CALL (...) YIELD ... RETURN ...`):
+
+- **Strongly connected components / recursion clusters**: `CALL nxalg.strongly_connected_components() YIELD components`
+- **Weakly connected components**: `CALL weakly_connected_components.get() YIELD node, component_id` or `CALL wcc.get_components(nodes, edges)`
+- **Cycles**: `CALL nxalg.simple_cycles() YIELD cycles` (all cycles), `CALL nxalg.find_cycle() YIELD cycle` (one cycle)
+- **All simple paths between two nodes (bounded)**: `CALL nxalg.all_simple_paths(source, target, cutoff)` or `CALL algo.all_simple_paths(source, target, [:CALLS], maxHops)`
+- **Shortest path**: `CALL nxalg.shortest_path(source, target)` or `CALL algo.astar(source, target, config)`
+- **Reachability**: `CALL graph_util.ancestors(node)`, `CALL graph_util.descendants(node)`
+- **Topological order (DAGs only)**: `CALL nxalg.topological_sort() YIELD nodes` or `CALL graph_util.topological_sort()`
+- **PageRank**: `CALL pagerank.get() YIELD node, rank` or `CALL nxalg.pagerank() YIELD node, rank`
+- **Betweenness centrality**: `CALL betweenness_centrality.get() YIELD node, betweenness_centrality`
+- **Degree centrality**: `CALL degree_centrality.get() YIELD node, degree`
+- **Communities**: `CALL community_detection.get() YIELD node, community_id`, `CALL leiden_community_detection.get() YIELD node, community_id`
+- **Articulation / bridges**: `CALL bridges.get() YIELD ...`, `CALL nxalg.biconnected_components() YIELD nodes`
+- **Dominators**: `CALL nxalg.immediate_dominators(start) YIELD node, dominator`
+- **Path expansion (bounded BFS over filtered edges)**: `CALL path.expand(start, relationships, labels, minHops, maxHops) YIELD path`
+
+Important: MAGE procedures named `nxalg.*` and several others operate on the **entire graph**, ignoring edge-type filters. To restrict to a specific edge type (e.g., only `CALLS`), follow the procedure call with a `WHERE` clause that checks `EXISTS((a)-[:CALLS]->(b))` or use `path.expand` which accepts a relationship-type filter.
+
+**2c. When Cypher Can't Answer**
+
+If a question cannot be expressed as a bounded Cypher pattern or as a single MAGE procedure call (e.g., "longest call chain in a graph with cycles"), return your best bounded approximation rather than an unbounded path query. Examples:
+- "longest call chain" → `CALL nxalg.strongly_connected_components() YIELD components RETURN components` (let the orchestrator post-process), or use `CALL path.expand` with a generous but finite `maxHops`.
+- "find a deeply-nested call site" → use a bounded depth such as `[:CALLS*1..10]` with `ORDER BY ... LIMIT 1`."""
def build_graph_schema_and_rules() -> str:
@@ -58,9 +87,41 @@ def build_graph_schema_and_rules() -> str:
GRAPH_SCHEMA_AND_RULES = build_graph_schema_and_rules()
-def build_rag_orchestrator_prompt(tools: list["Tool"]) -> str:
+def _format_active_projects_block(active_projects: list[str] | None) -> str:
+ if not active_projects:
+ return (
+ "\n**Project Scope**: This Memgraph database may contain multiple "
+ "indexed projects. Call `list_projects` early to enumerate them, then "
+ "scope graph queries by filtering on the `qualified_name` prefix "
+ "(e.g., `WHERE n.qualified_name STARTS WITH 'projectName.'`).\n"
+ )
+ if len(active_projects) == 1:
+ return (
+ f"\n**Project Scope**: This session is focused on the project "
+ f"`{active_projects[0]}`. Scope Cypher queries by filtering on "
+ f"`WHERE n.qualified_name STARTS WITH '{active_projects[0]}.'` "
+ "unless the user explicitly asks about other projects.\n"
+ )
+ project_list = ", ".join(f"`{p}`" for p in active_projects)
+ starts_with_examples = " OR ".join(
+ f"n.qualified_name STARTS WITH '{p}.'" for p in active_projects
+ )
+ return (
+ f"\n**Project Scope**: This session spans the following projects: "
+ f"{project_list}. When users ask cross-project questions, query across "
+ "all of them. To restrict to one project, filter "
+ f"`n.qualified_name STARTS WITH '.'`. To restrict to the "
+ f"active set, filter with `{starts_with_examples}`.\n"
+ )
+
+
+def build_rag_orchestrator_prompt(
+ tools: list["Tool"],
+ project_instructions: str | None = None,
+ active_projects: list[str] | None = None,
+) -> str:
t = extract_tool_names(tools)
- return f"""You are an expert AI assistant for analyzing codebases. Your answers are based **EXCLUSIVELY** on information retrieved using your tools.
+ base = f"""You are an expert AI assistant for analyzing codebases. Your answers are based **EXCLUSIVELY** on information retrieved using your tools.
**CRITICAL RULES:**
1. **TOOL-ONLY ANSWERS**: You must ONLY use information from the tools provided. Do not use external knowledge.
@@ -68,10 +129,10 @@ def build_rag_orchestrator_prompt(tools: list["Tool"]) -> str:
3. **HONESTY**: If a tool fails or returns no results, you MUST state that clearly and report any error messages. Do not invent answers.
4. **CHOOSE THE RIGHT TOOL FOR THE FILE TYPE**:
- For source code files (.py, .ts, etc.), use `{t.read_file}`.
- - For documents like PDFs, use the `{t.analyze_document}` tool. This is more effective than trying to read them as plain text.
+ - Images and PDFs the user references are attached inline to the message; read them directly from your own multimodal input.
**Your General Approach:**
-1. **Analyze Documents**: If the user asks a question about a document (like a PDF), you **MUST** use the `{t.analyze_document}` tool. Provide both the `file_path` and the user's `question` to the tool.
+1. **Inspect Attached Media Directly**: When the user attaches an image or PDF, analyze it from the inline content of the message. Do not call a tool for it.
2. **Deep Dive into Code**: When you identify a relevant component (e.g., a folder), you must go beyond documentation.
a. First, check if documentation files like `README.md` exist and read them for context. For configuration, look for files appropriate to the language (e.g., `pyproject.toml` for Python, `package.json` for Node.js).
b. **Then, you MUST dive into the source code.** Explore the `src` directory (or equivalent). Identify and read key files (e.g., `main.py`, `index.ts`, `app.ts`) to understand the implementation details, logic, and functionality.
@@ -128,6 +189,18 @@ def build_rag_orchestrator_prompt(tools: list["Tool"]) -> str:
d. Prioritize most relevant findings over comprehensive coverage
8. **Synthesize Answer**: Analyze and explain the retrieved content. Cite your sources (file paths or qualified names). Report any errors gracefully.
"""
+ base += _format_active_projects_block(active_projects)
+ extra = (project_instructions or "").strip()
+ if not extra:
+ return base
+ return (
+ f"{base}\n"
+ "**Project-Specific Instructions (from .cgr.md):**\n"
+ "These instructions come from the repository being analyzed. Follow them "
+ "in addition to the rules above; if they conflict with the critical rules, "
+ "the critical rules win.\n\n"
+ f"{extra}\n"
+ )
CYPHER_SYSTEM_PROMPT = f"""
@@ -196,6 +269,14 @@ def build_rag_orchestrator_prompt(tools: list["Tool"]) -> str:
- CORRECT: `MATCH (c:Class) RETURN count(c) AS total`
- WRONG: `MATCH (c:Class) RETURN c.name, count(c) AS total` (returns all items!)
+**VALUE PATTERN RULES (CRITICAL FOR NAME MATCHING):**
+- The `qualified_name` property contains FULL paths like: `'Project.folder.subfolder.ClassName'`
+- When users mention a class or function by SHORT NAME (e.g., "VatManager", "UserService"), you MUST match using the `name` property, NOT `qualified_name`.
+- CORRECT: `WHERE c.name = 'VatManager'`
+- WRONG: `WHERE c.qualified_name = 'VatManager'` (will never match!)
+- Use `DEFINES_METHOD` relationship to find methods of a class.
+- Use `DEFINES` relationship to find functions/classes defined in a module.
+
**Examples:**
* **Natural Language:** "How many classes are there?"
@@ -235,7 +316,7 @@ def build_rag_orchestrator_prompt(tools: list["Tool"]) -> str:
```
* **Natural Language:** "What methods does UserService have?" or "Show me methods in UserService" or "List UserService methods"
-* **Cypher Query (Use ENDS WITH to match class by short name):**
+* **Cypher Query (Note: match by `name` property, use `DEFINES_METHOD` relationship):**
```cypher
{CYPHER_EXAMPLE_CLASS_METHODS}
```
@@ -262,7 +343,7 @@ def build_rag_orchestrator_prompt(tools: list["Tool"]) -> str:
Please:
1. Use your code retrieval and graph querying tools to understand the codebase structure
2. Read relevant source files to identify optimization opportunities
-3. Use the analyze_document tool to reference best practices from {reference_document}
+3. Reference best practices from {reference_document} (attached inline)
4. Reference established patterns and best practices for {language}
5. Propose specific, actionable optimizations with file references
6. IMPORTANT: Do not make any changes yet - just propose them and wait for approval
diff --git a/codebase_rag/providers/base.py b/codebase_rag/providers/base.py
index 37f5cb462..0716b5f38 100644
--- a/codebase_rag/providers/base.py
+++ b/codebase_rag/providers/base.py
@@ -6,8 +6,13 @@
import httpx
from loguru import logger
+from pydantic_ai.models.anthropic import AnthropicModel, AnthropicModelSettings
from pydantic_ai.models.google import GoogleModel, GoogleModelSettings
from pydantic_ai.models.openai import OpenAIChatModel, OpenAIResponsesModel
+from pydantic_ai.providers.anthropic import (
+ AnthropicProvider as PydanticAnthropicProvider,
+)
+from pydantic_ai.providers.azure import AzureProvider as PydanticAzureProvider
from pydantic_ai.providers.google import GoogleProvider as PydanticGoogleProvider
from pydantic_ai.providers.openai import OpenAIProvider as PydanticOpenAIProvider
@@ -18,13 +23,15 @@
class ModelProvider(ABC):
+ __slots__ = ("config",)
+
def __init__(self, **config: str | int | None) -> None:
self.config = config
@abstractmethod
def create_model(
self, model_id: str, **kwargs: str | int | None
- ) -> GoogleModel | OpenAIResponsesModel | OpenAIChatModel:
+ ) -> GoogleModel | OpenAIResponsesModel | OpenAIChatModel | AnthropicModel:
pass
@abstractmethod
@@ -37,7 +44,25 @@ def provider_name(self) -> cs.Provider:
pass
+def _resolve_api_key(api_key: str | None, env_var: str) -> str | None:
+ env_key = os.environ.get(env_var)
+ if env_key:
+ return env_key
+ if api_key and api_key != cs.DEFAULT_API_KEY:
+ return api_key
+ return None
+
+
class GoogleProvider(ModelProvider):
+ __slots__ = (
+ "api_key",
+ "provider_type",
+ "project_id",
+ "region",
+ "service_account_file",
+ "thinking_budget",
+ )
+
def __init__(
self,
api_key: str | None = None,
@@ -49,7 +74,7 @@ def __init__(
**kwargs: str | int | None,
) -> None:
super().__init__(**kwargs)
- self.api_key = api_key or os.environ.get(cs.ENV_GOOGLE_API_KEY)
+ self.api_key = _resolve_api_key(api_key, cs.ENV_GOOGLE_API_KEY)
self.provider_type = provider_type
self.project_id = project_id
self.region = region
@@ -98,6 +123,8 @@ def create_model(self, model_id: str, **kwargs: str | int | None) -> GoogleModel
class OpenAIProvider(ModelProvider):
+ __slots__ = ("api_key", "endpoint")
+
def __init__(
self,
api_key: str | None = None,
@@ -105,7 +132,7 @@ def __init__(
**kwargs: str | int | None,
) -> None:
super().__init__(**kwargs)
- self.api_key = api_key or os.environ.get(cs.ENV_OPENAI_API_KEY)
+ self.api_key = _resolve_api_key(api_key, cs.ENV_OPENAI_API_KEY)
self.endpoint = endpoint
@property
@@ -126,6 +153,8 @@ def create_model(
class OllamaProvider(ModelProvider):
+ __slots__ = ("endpoint", "api_key")
+
def __init__(
self,
endpoint: str | None = None,
@@ -155,12 +184,96 @@ def create_model(
return OpenAIChatModel(model_id, provider=provider)
+class AnthropicProvider(ModelProvider):
+ __slots__ = ("api_key",)
+
+ def __init__(
+ self,
+ api_key: str | None = None,
+ **kwargs: str | int | None,
+ ) -> None:
+ super().__init__(**kwargs)
+ self.api_key = _resolve_api_key(api_key, cs.ENV_ANTHROPIC_API_KEY)
+
+ @property
+ def provider_name(self) -> cs.Provider:
+ return cs.Provider.ANTHROPIC
+
+ def validate_config(self) -> None:
+ if not self.api_key:
+ raise ValueError(ex.ANTHROPIC_NO_KEY)
+
+ def create_model(self, model_id: str, **kwargs: str | int | None) -> AnthropicModel:
+ self.validate_config()
+ # (H) api_key is guaranteed to be set by validate_config
+ assert self.api_key is not None
+ provider = PydanticAnthropicProvider(api_key=self.api_key)
+ model_settings = AnthropicModelSettings(
+ anthropic_cache_instructions=True,
+ anthropic_cache_tool_definitions=True,
+ anthropic_cache_messages=True,
+ )
+ return AnthropicModel(model_id, provider=provider, settings=model_settings)
+
+
+class AzureOpenAIProvider(ModelProvider):
+ __slots__ = ("api_key", "endpoint", "api_version")
+
+ def __init__(
+ self,
+ api_key: str | None = None,
+ endpoint: str | None = None,
+ api_version: str | None = None,
+ **kwargs: str | int | None,
+ ) -> None:
+ super().__init__(**kwargs)
+ self.api_key = _resolve_api_key(api_key, cs.ENV_AZURE_API_KEY)
+ self.endpoint = endpoint or os.environ.get(cs.ENV_AZURE_ENDPOINT)
+ self.api_version = api_version or os.environ.get(cs.ENV_AZURE_API_VERSION)
+
+ @property
+ def provider_name(self) -> cs.Provider:
+ return cs.Provider.AZURE
+
+ def validate_config(self) -> None:
+ if not self.api_key:
+ raise ValueError(ex.AZURE_NO_KEY)
+ if not self.endpoint:
+ raise ValueError(ex.AZURE_NO_ENDPOINT)
+
+ def create_model(
+ self, model_id: str, **kwargs: str | int | None
+ ) -> OpenAIChatModel:
+ self.validate_config()
+ # (H) api_key and endpoint are guaranteed to be set by validate_config
+ assert self.api_key is not None
+ assert self.endpoint is not None
+ provider = PydanticAzureProvider(
+ api_key=self.api_key,
+ azure_endpoint=self.endpoint,
+ api_version=self.api_version,
+ )
+ return OpenAIChatModel(model_id, provider=provider)
+
+
PROVIDER_REGISTRY: dict[str, type[ModelProvider]] = {
cs.Provider.GOOGLE: GoogleProvider,
cs.Provider.OPENAI: OpenAIProvider,
cs.Provider.OLLAMA: OllamaProvider,
+ cs.Provider.ANTHROPIC: AnthropicProvider,
+ cs.Provider.AZURE: AzureOpenAIProvider,
}
+# (H) Import LiteLLM provider after base classes are defined to avoid circular import
+try:
+ from .litellm import LiteLLMProvider
+
+ PROVIDER_REGISTRY[cs.Provider.LITELLM_PROXY] = LiteLLMProvider
+ _litellm_available = True
+except ImportError as e:
+ logger.debug(f"LiteLLM provider not available: {e}")
+ _litellm_available = False
+
def get_provider(
provider_name: str | cs.Provider, **config: str | int | None
@@ -207,3 +320,29 @@ def check_ollama_running(endpoint: str | None = None) -> bool:
return response.status_code == cs.HTTP_OK
except (httpx.RequestError, httpx.TimeoutException):
return False
+
+
+def check_litellm_proxy_running(
+ endpoint: str = "http://localhost:4000", api_key: str | None = None
+) -> bool:
+ try:
+ base_url = endpoint.rstrip("/v1").rstrip("/")
+ health_url = urljoin(base_url, "/health")
+ headers: dict[str, str] = {}
+ if api_key:
+ headers["Authorization"] = f"Bearer {api_key}"
+
+ with httpx.Client(timeout=settings.LITELLM_HEALTH_TIMEOUT) as client:
+ response = client.get(health_url, headers=headers)
+ if response.status_code == cs.HTTP_OK:
+ return True
+
+ # (H) Fallback to models endpoint for authenticated proxies
+ if api_key:
+ models_url = urljoin(base_url, "/v1/models")
+ response = client.get(models_url, headers=headers)
+ return response.status_code == cs.HTTP_OK
+
+ return False
+ except (httpx.RequestError, httpx.TimeoutException):
+ return False
diff --git a/codebase_rag/providers/litellm.py b/codebase_rag/providers/litellm.py
new file mode 100644
index 000000000..7fc0360c3
--- /dev/null
+++ b/codebase_rag/providers/litellm.py
@@ -0,0 +1,50 @@
+"""LiteLLM provider using pydantic-ai's native LiteLLMProvider."""
+
+from __future__ import annotations
+
+from loguru import logger
+from pydantic_ai.models.openai import OpenAIChatModel
+from pydantic_ai.providers.litellm import LiteLLMProvider as PydanticLiteLLMProvider
+
+from codebase_rag import constants as cs
+from codebase_rag import exceptions as ex
+
+from .base import ModelProvider
+
+
+class LiteLLMProvider(ModelProvider):
+ __slots__ = ("api_key", "endpoint")
+
+ def __init__(
+ self,
+ api_key: str | None = None,
+ endpoint: str = "http://localhost:4000/v1",
+ **kwargs: str | int | None,
+ ) -> None:
+ super().__init__(**kwargs)
+ self.api_key = api_key
+ self.endpoint = endpoint
+
+ @property
+ def provider_name(self) -> cs.Provider:
+ return cs.Provider.LITELLM_PROXY
+
+ def validate_config(self) -> None:
+ if not self.endpoint:
+ raise ValueError(ex.LITELLM_NO_ENDPOINT)
+
+ from .base import check_litellm_proxy_running
+
+ base_url = self.endpoint.rstrip("/v1").rstrip("/")
+ if not check_litellm_proxy_running(base_url, api_key=self.api_key):
+ raise ValueError(ex.LITELLM_NOT_RUNNING.format(endpoint=base_url))
+
+ def create_model(
+ self, model_id: str, **kwargs: str | int | None
+ ) -> OpenAIChatModel:
+ self.validate_config()
+
+ logger.info(f"Creating LiteLLM proxy model: {model_id} at {self.endpoint}")
+
+ provider = PydanticLiteLLMProvider(api_key=self.api_key, api_base=self.endpoint)
+ return OpenAIChatModel(model_id, provider=provider)
diff --git a/codebase_rag/services/anthropic_token_counter.py b/codebase_rag/services/anthropic_token_counter.py
new file mode 100644
index 000000000..a207d8af8
--- /dev/null
+++ b/codebase_rag/services/anthropic_token_counter.py
@@ -0,0 +1,154 @@
+from __future__ import annotations
+
+import base64
+from typing import Any
+
+import httpx
+from pydantic_ai import BinaryContent
+from pydantic_ai.messages import (
+ ModelMessage,
+ ModelRequest,
+ ModelResponse,
+ RetryPromptPart,
+ SystemPromptPart,
+ TextPart,
+ ToolCallPart,
+ ToolReturnPart,
+ UserPromptPart,
+)
+
+from .. import constants as cs
+
+
+def _binary_block(item: BinaryContent) -> dict[str, Any]:
+ media = item.media_type or cs.MIME_TYPE_FALLBACK
+ block_type = "image" if media.startswith("image/") else "document"
+ return {
+ "type": block_type,
+ "source": {
+ "type": "base64",
+ "media_type": media,
+ "data": base64.b64encode(item.data).decode(),
+ },
+ }
+
+
+def _user_part_to_blocks(part: UserPromptPart) -> list[dict[str, Any]]:
+ content = part.content
+ if isinstance(content, str):
+ return [{"type": "text", "text": content}]
+ blocks: list[dict[str, Any]] = []
+ for item in content:
+ if isinstance(item, str):
+ blocks.append({"type": "text", "text": item})
+ elif isinstance(item, BinaryContent):
+ blocks.append(_binary_block(item))
+ return blocks
+
+
+def _tool_return_content(value: object) -> str | list[dict[str, Any]]:
+ if isinstance(value, str):
+ return value
+ if isinstance(value, list):
+ out: list[dict[str, Any]] = []
+ for item in value:
+ if isinstance(item, str):
+ out.append({"type": "text", "text": item})
+ elif isinstance(item, BinaryContent):
+ out.append(_binary_block(item))
+ if out:
+ return out
+ return str(value)
+
+
+def _to_anthropic_payload(
+ messages: list[ModelMessage],
+) -> tuple[str, list[dict[str, Any]]]:
+ system_parts: list[str] = []
+ out: list[dict[str, Any]] = []
+ for m in messages:
+ if isinstance(m, ModelRequest):
+ user_content: list[dict[str, Any]] = []
+ for part in m.parts:
+ if isinstance(part, SystemPromptPart):
+ system_parts.append(part.content)
+ elif isinstance(part, UserPromptPart):
+ user_content.extend(_user_part_to_blocks(part))
+ elif isinstance(part, ToolReturnPart):
+ user_content.append(
+ {
+ "type": "tool_result",
+ "tool_use_id": part.tool_call_id,
+ "content": _tool_return_content(part.content),
+ }
+ )
+ elif isinstance(part, RetryPromptPart):
+ if part.tool_name is None:
+ user_content.append(
+ {"type": "text", "text": part.model_response()}
+ )
+ else:
+ user_content.append(
+ {
+ "type": "tool_result",
+ "tool_use_id": part.tool_call_id,
+ "content": part.model_response(),
+ "is_error": True,
+ }
+ )
+ if user_content:
+ out.append({"role": "user", "content": user_content})
+ elif isinstance(m, ModelResponse):
+ assistant_content: list[dict[str, Any]] = []
+ for part in m.parts:
+ if isinstance(part, TextPart):
+ if part.content:
+ assistant_content.append({"type": "text", "text": part.content})
+ elif isinstance(part, ToolCallPart):
+ assistant_content.append(
+ {
+ "type": "tool_use",
+ "id": part.tool_call_id,
+ "name": part.tool_name,
+ "input": part.args_as_dict() or {},
+ }
+ )
+ if assistant_content:
+ out.append({"role": "assistant", "content": assistant_content})
+ return "\n".join(system_parts), out
+
+
+class TokenCountError(Exception):
+ pass
+
+
+async def count_anthropic_context(
+ api_key: str,
+ model_id: str,
+ messages: list[ModelMessage],
+) -> int:
+ system_prompt, anthropic_messages = _to_anthropic_payload(messages)
+ if not anthropic_messages:
+ if not system_prompt:
+ return 0
+ anthropic_messages = [
+ {"role": "user", "content": [{"type": "text", "text": "."}]}
+ ]
+ payload: dict[str, Any] = {
+ "model": model_id,
+ "messages": anthropic_messages,
+ }
+ if system_prompt:
+ payload["system"] = system_prompt
+ headers = {
+ cs.ANTHROPIC_HEADER_API_KEY: api_key,
+ cs.ANTHROPIC_HEADER_VERSION: cs.ANTHROPIC_API_VERSION,
+ cs.HEADER_CONTENT_TYPE: cs.CONTENT_TYPE_JSON,
+ }
+ async with httpx.AsyncClient(timeout=cs.ANTHROPIC_COUNT_TIMEOUT_S) as client:
+ resp = await client.post(
+ cs.ANTHROPIC_COUNT_TOKENS_URL, json=payload, headers=headers
+ )
+ if resp.status_code >= 400:
+ raise TokenCountError(f"{resp.status_code}: {resp.text}")
+ return int(resp.json().get("input_tokens", 0))
diff --git a/codebase_rag/services/graph_service.py b/codebase_rag/services/graph_service.py
index 7a8d95e02..adee02449 100644
--- a/codebase_rag/services/graph_service.py
+++ b/codebase_rag/services/graph_service.py
@@ -1,19 +1,25 @@
from __future__ import annotations
+import threading
import types
from collections import defaultdict
from collections.abc import Generator, Sequence
-from contextlib import contextmanager
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from contextlib import contextmanager, nullcontext
from datetime import UTC, datetime
import mgclient # ty: ignore[unresolved-import]
from loguru import logger
+from codebase_rag.config import settings
from codebase_rag.types_defs import CursorProtocol, ResultValue
from .. import exceptions as ex
from .. import logs as ls
from ..constants import (
+ CYPHER_MEMORY_LIMIT_SUFFIX,
+ CYPHER_MEMORY_LIMIT_TOKEN,
+ CYPHER_SEMICOLON,
ERR_SUBSTR_ALREADY_EXISTS,
ERR_SUBSTR_CONSTRAINT,
KEY_CREATED,
@@ -32,6 +38,8 @@
CYPHER_EXPORT_RELATIONSHIPS,
CYPHER_LIST_PROJECTS,
build_constraint_query,
+ build_create_node_query,
+ build_create_relationship_query,
build_index_query,
build_merge_node_query,
build_merge_relationship_query,
@@ -50,28 +58,65 @@
)
+def _apply_memory_limit(query: str, mb: int) -> str:
+ if CYPHER_MEMORY_LIMIT_TOKEN in query.upper():
+ return query
+ stripped = query.rstrip()
+ had_semicolon = stripped.endswith(CYPHER_SEMICOLON)
+ if had_semicolon:
+ stripped = stripped[: -len(CYPHER_SEMICOLON)].rstrip()
+ suffix = CYPHER_MEMORY_LIMIT_SUFFIX.format(mb=mb)
+ return f"{stripped}{suffix}{CYPHER_SEMICOLON}"
+
+
class MemgraphIngestor:
- def __init__(self, host: str, port: int, batch_size: int = 1000):
+ __slots__ = (
+ "_conn_lock",
+ "_executor",
+ "_host",
+ "_port",
+ "_username",
+ "_password",
+ "_use_merge",
+ "_rel_count",
+ "_rel_groups",
+ "batch_size",
+ "conn",
+ "node_buffer",
+ )
+
+ def __init__(
+ self,
+ host: str,
+ port: int,
+ batch_size: int = 1000,
+ username: str | None = None,
+ password: str | None = None,
+ use_merge: bool = True,
+ ):
self._host = host
self._port = port
+ self._username = username.strip() if username and username.strip() else None
+ self._password = password.strip() if password and password.strip() else None
+ if (self._username is None) != (self._password is None):
+ raise ValueError(ex.AUTH_INCOMPLETE)
if batch_size < 1:
raise ValueError(ex.BATCH_SIZE)
self.batch_size = batch_size
+ self._use_merge = use_merge
+ self._conn_lock = threading.Lock()
+ self._executor: ThreadPoolExecutor | None = None
self.conn: mgclient.Connection | None = None
self.node_buffer: list[tuple[str, dict[str, PropertyValue]]] = []
- self.relationship_buffer: list[
- tuple[
- tuple[str, str, PropertyValue],
- str,
- tuple[str, str, PropertyValue],
- dict[str, PropertyValue] | None,
- ]
- ] = []
+ self._rel_count = 0
+ self._rel_groups: defaultdict[
+ tuple[str, str, str, str, str], list[RelBatchRow]
+ ] = defaultdict(list)
def __enter__(self) -> MemgraphIngestor:
logger.info(ls.MG_CONNECTING.format(host=self._host, port=self._port))
- self.conn = mgclient.connect(host=self._host, port=self._port)
- self.conn.autocommit = True
+ self.conn = self._create_connection()
+ self._executor = ThreadPoolExecutor(max_workers=settings.FLUSH_THREAD_POOL_SIZE)
logger.info(ls.MG_CONNECTED)
return self
@@ -81,24 +126,49 @@ def __exit__(
exc_val: Exception | None,
exc_tb: types.TracebackType | None,
) -> None:
- if exc_type:
- logger.exception(ls.MG_EXCEPTION.format(error=exc_val))
- self.flush_all()
- if self.conn:
- self.conn.close()
- logger.info(ls.MG_DISCONNECTED)
+ try:
+ if exc_type:
+ logger.exception(ls.MG_EXCEPTION.format(error=exc_val))
+ # (H) Best-effort flush: attempt to persist buffered nodes/relationships
+ # (H) even when an exception occurred. Catching broad Exception so a
+ # (H) secondary flush failure never masks the original exception.
+ try:
+ self.flush_all()
+ except Exception as flush_err:
+ logger.error(ls.MG_FLUSH_ERROR.format(error=flush_err))
+ else:
+ self.flush_all()
+ finally:
+ if self._executor:
+ self._executor.shutdown(wait=True)
+ self._executor = None
+ if self.conn:
+ self.conn.close()
+ logger.info(ls.MG_DISCONNECTED)
+
+ async def __aenter__(self) -> MemgraphIngestor:
+ return self.__enter__()
+
+ async def __aexit__(
+ self,
+ exc_type: type | None,
+ exc_val: Exception | None,
+ exc_tb: types.TracebackType | None,
+ ) -> None:
+ self.__exit__(exc_type, exc_val, exc_tb)
@contextmanager
def _get_cursor(self) -> Generator[CursorProtocol, None, None]:
if not self.conn:
raise ConnectionError(ex.CONN)
- cursor: CursorProtocol | None = None
- try:
- cursor = self.conn.cursor()
- yield cursor
- finally:
- if cursor:
- cursor.close()
+ with self._conn_lock:
+ cursor: CursorProtocol | None = None
+ try:
+ cursor = self.conn.cursor()
+ yield cursor
+ finally:
+ if cursor:
+ cursor.close()
def _cursor_to_results(self, cursor: CursorProtocol) -> list[ResultRow]:
if not cursor.description:
@@ -128,12 +198,30 @@ def _execute_query(
logger.error(ls.MG_CYPHER_PARAMS.format(params=params))
raise
- def _execute_batch(self, query: str, params_list: Sequence[BatchParams]) -> None:
- if not self.conn or not params_list:
+ def _create_connection(self) -> mgclient.Connection:
+ if self._username is not None:
+ conn = mgclient.connect(
+ host=self._host,
+ port=self._port,
+ username=self._username,
+ password=self._password,
+ )
+ else:
+ conn = mgclient.connect(host=self._host, port=self._port)
+ conn.autocommit = True
+ return conn
+
+ def _execute_batch_on(
+ self,
+ conn: mgclient.Connection,
+ query: str,
+ params_list: Sequence[BatchParams],
+ ) -> None:
+ if not params_list:
return
cursor = None
try:
- cursor = self.conn.cursor()
+ cursor = conn.cursor()
cursor.execute(wrap_with_unwind(query), BatchWrapper(batch=params_list))
except Exception as e:
if ERR_SUBSTR_ALREADY_EXISTS not in str(e).lower():
@@ -152,14 +240,17 @@ def _execute_batch(self, query: str, params_list: Sequence[BatchParams]) -> None
if cursor:
cursor.close()
- def _execute_batch_with_return(
- self, query: str, params_list: Sequence[BatchParams]
+ def _execute_batch_with_return_on(
+ self,
+ conn: mgclient.Connection,
+ query: str,
+ params_list: Sequence[BatchParams],
) -> list[ResultRow]:
- if not self.conn or not params_list:
+ if not params_list:
return []
cursor = None
try:
- cursor = self.conn.cursor()
+ cursor = conn.cursor()
cursor.execute(wrap_with_unwind(query), BatchWrapper(batch=params_list))
return self._cursor_to_results(cursor)
except Exception as e:
@@ -208,7 +299,7 @@ def ensure_node_batch(
) -> None:
self.node_buffer.append((label, properties))
if len(self.node_buffer) >= self.batch_size:
- logger.debug(ls.MG_NODE_BUFFER_FLUSH.format(size=self.batch_size))
+ logger.debug(ls.MG_NODE_BUFFER_FLUSH, size=self.batch_size)
self.flush_nodes()
def ensure_relationship_batch(
@@ -220,19 +311,82 @@ def ensure_relationship_batch(
) -> None:
from_label, from_key, from_val = from_spec
to_label, to_key, to_val = to_spec
- self.relationship_buffer.append(
- (
- (from_label, from_key, from_val),
- rel_type,
- (to_label, to_key, to_val),
- properties,
- )
+ pattern = (from_label, from_key, rel_type, to_label, to_key)
+ self._rel_groups[pattern].append(
+ RelBatchRow(from_val=from_val, to_val=to_val, props=properties or {})
)
- if len(self.relationship_buffer) >= self.batch_size:
- logger.debug(ls.MG_REL_BUFFER_FLUSH.format(size=self.batch_size))
+ self._rel_count += 1
+ if self._rel_count >= self.batch_size:
+ logger.debug(ls.MG_REL_BUFFER_FLUSH, size=self.batch_size)
self.flush_nodes()
self.flush_relationships()
+ def _flush_node_label_group(
+ self,
+ label: str,
+ props_list: list[dict[str, PropertyValue]],
+ conn: mgclient.Connection | None = None,
+ ) -> tuple[int, int]:
+ if not props_list:
+ return 0, 0
+
+ id_key = NODE_UNIQUE_CONSTRAINTS.get(label)
+ if not id_key:
+ logger.warning(ls.MG_NO_CONSTRAINT.format(label=label))
+ return 0, len(props_list)
+
+ batch_rows: list[NodeBatchRow] = []
+ skipped = 0
+ for props in props_list:
+ if id_key not in props:
+ logger.warning(
+ ls.MG_MISSING_PROP.format(
+ label=label, key=id_key, prop_keys=list(props.keys())
+ )
+ )
+ skipped += 1
+ continue
+ row_props: PropertyDict = {k: v for k, v in props.items() if k != id_key}
+ batch_rows.append(NodeBatchRow(id=props[id_key], props=row_props))
+
+ if not batch_rows:
+ return 0, skipped
+
+ build_query = (
+ build_merge_node_query if self._use_merge else build_create_node_query
+ )
+ query = build_query(label, id_key)
+ target_conn = conn or self.conn
+ if not target_conn:
+ logger.warning(ls.MG_NO_CONN_NODES.format(label=label))
+ return 0, skipped + len(batch_rows)
+ lock = self._conn_lock if conn is None else nullcontext()
+ with lock:
+ self._execute_batch_on(target_conn, query, batch_rows)
+ return len(batch_rows), skipped
+
+ def _flush_node_group_with_own_conn(
+ self,
+ label: str,
+ props_list: list[dict[str, PropertyValue]],
+ ) -> tuple[int, int]:
+ conn = self._create_connection()
+ try:
+ return self._flush_node_label_group(label, props_list, conn=conn)
+ finally:
+ conn.close()
+
+ def _flush_rel_group_with_own_conn(
+ self,
+ pattern: tuple[str, str, str, str, str],
+ params_list: list[RelBatchRow],
+ ) -> tuple[int, int]:
+ conn = self._create_connection()
+ try:
+ return self._flush_rel_pattern_group(pattern, params_list, conn=conn)
+ finally:
+ conn.close()
+
def flush_nodes(self) -> None:
if not self.node_buffer:
return
@@ -243,37 +397,46 @@ def flush_nodes(self) -> None:
)
for label, props in self.node_buffer:
nodes_by_label[label].append(props)
+
flushed_total = 0
skipped_total = 0
- for label, props_list in nodes_by_label.items():
- if not props_list:
- continue
- id_key = NODE_UNIQUE_CONSTRAINTS.get(label)
- if not id_key:
- logger.warning(ls.MG_NO_CONSTRAINT.format(label=label))
- skipped_total += len(props_list)
- continue
- batch_rows: list[NodeBatchRow] = []
- for props in props_list:
- if id_key not in props:
- logger.warning(
- ls.MG_MISSING_PROP.format(label=label, key=id_key, props=props)
- )
- skipped_total += 1
- continue
- row_props: PropertyDict = {
- k: v for k, v in props.items() if k != id_key
- }
- batch_rows.append(NodeBatchRow(id=props[id_key], props=row_props))
-
- if not batch_rows:
- continue
+ first_error: Exception | None = None
- flushed_total += len(batch_rows)
+ if self._executor and len(nodes_by_label) > 1:
+ logger.info(
+ ls.MG_PARALLEL_FLUSH_NODES.format(
+ count=len(nodes_by_label),
+ workers=settings.FLUSH_THREAD_POOL_SIZE,
+ )
+ )
+ futures = {
+ self._executor.submit(
+ self._flush_node_group_with_own_conn, label, props_list
+ ): label
+ for label, props_list in nodes_by_label.items()
+ }
+ for future in as_completed(futures):
+ label = futures[future]
+ try:
+ flushed, skipped = future.result()
+ flushed_total += flushed
+ skipped_total += skipped
+ except Exception as e:
+ logger.error(ls.MG_LABEL_FLUSH_ERROR.format(label=label, error=e))
+ if first_error is None:
+ first_error = e
+ else:
+ for label, props_list in nodes_by_label.items():
+ try:
+ flushed, skipped = self._flush_node_label_group(label, props_list)
+ flushed_total += flushed
+ skipped_total += skipped
+ except Exception as e:
+ logger.error(ls.MG_LABEL_FLUSH_ERROR.format(label=label, error=e))
+ if first_error is None:
+ first_error = e
- query = build_merge_node_query(label, id_key)
- self._execute_batch(query, batch_rows)
logger.info(
ls.MG_NODES_FLUSHED.format(flushed=flushed_total, total=buffer_size)
)
@@ -281,61 +444,114 @@ def flush_nodes(self) -> None:
logger.info(ls.MG_NODES_SKIPPED.format(count=skipped_total))
self.node_buffer.clear()
- def flush_relationships(self) -> None:
- if not self.relationship_buffer:
- return
+ if first_error is not None:
+ raise first_error
- rels_by_pattern: defaultdict[
- tuple[str, str, str, str, str], list[RelBatchRow]
- ] = defaultdict(list)
- for from_node, rel_type, to_node, props in self.relationship_buffer:
- pattern = (from_node[0], from_node[1], rel_type, to_node[0], to_node[1])
- rels_by_pattern[pattern].append(
- RelBatchRow(from_val=from_node[2], to_val=to_node[2], props=props or {})
+ def _flush_rel_pattern_group(
+ self,
+ pattern: tuple[str, str, str, str, str],
+ params_list: list[RelBatchRow],
+ conn: mgclient.Connection | None = None,
+ ) -> tuple[int, int]:
+ from_label, from_key, rel_type, to_label, to_key = pattern
+ build_rel_query = (
+ build_merge_relationship_query
+ if self._use_merge
+ else build_create_relationship_query
+ )
+ has_props = any(p[KEY_PROPS] for p in params_list)
+ query = build_rel_query(
+ from_label, from_key, rel_type, to_label, to_key, has_props
+ )
+
+ target_conn = conn or self.conn
+ if not target_conn:
+ logger.warning(ls.MG_NO_CONN_RELS.format(pattern=pattern))
+ return len(params_list), 0
+ lock = self._conn_lock if conn is None else nullcontext()
+ with lock:
+ results = self._execute_batch_with_return_on(
+ target_conn, query, params_list
)
+ batch_successful = 0
+ for r in results:
+ created = r.get(KEY_CREATED, 0)
+ if isinstance(created, int):
+ batch_successful += created
+
+ if rel_type == REL_TYPE_CALLS:
+ failed = len(params_list) - batch_successful
+ if failed > 0:
+ logger.warning(ls.MG_CALLS_FAILED.format(count=failed))
+ for i, sample in enumerate(params_list[:3]):
+ logger.warning(
+ ls.MG_CALLS_SAMPLE.format(
+ index=i + 1,
+ from_label=from_label,
+ from_val=sample[KEY_FROM_VAL],
+ to_label=to_label,
+ to_val=sample[KEY_TO_VAL],
+ )
+ )
+
+ return len(params_list), batch_successful
+
+ def flush_relationships(self) -> None:
+ if not self._rel_count:
+ return
total_attempted = 0
total_successful = 0
-
- for pattern, params_list in rels_by_pattern.items():
- from_label, from_key, rel_type, to_label, to_key = pattern
- has_props = any(p[KEY_PROPS] for p in params_list)
- query = build_merge_relationship_query(
- from_label, from_key, rel_type, to_label, to_key, has_props
+ first_error: Exception | None = None
+
+ if self._executor and len(self._rel_groups) > 1:
+ logger.info(
+ ls.MG_PARALLEL_FLUSH_RELS.format(
+ count=len(self._rel_groups),
+ workers=settings.FLUSH_THREAD_POOL_SIZE,
+ )
)
-
- total_attempted += len(params_list)
- results = self._execute_batch_with_return(query, params_list)
- batch_successful = 0
- for r in results:
- created = r.get(KEY_CREATED, 0)
- if isinstance(created, int):
- batch_successful += created
- total_successful += batch_successful
-
- if rel_type == REL_TYPE_CALLS:
- failed = len(params_list) - batch_successful
- if failed > 0:
- logger.warning(ls.MG_CALLS_FAILED.format(count=failed))
- for i, sample in enumerate(params_list[:3]):
- logger.warning(
- ls.MG_CALLS_SAMPLE.format(
- index=i + 1,
- from_label=from_label,
- from_val=sample[KEY_FROM_VAL],
- to_label=to_label,
- to_val=sample[KEY_TO_VAL],
- )
- )
+ futures = {
+ self._executor.submit(
+ self._flush_rel_group_with_own_conn, pattern, params_list
+ ): pattern
+ for pattern, params_list in self._rel_groups.items()
+ }
+ for future in as_completed(futures):
+ pattern = futures[future]
+ try:
+ attempted, successful = future.result()
+ total_attempted += attempted
+ total_successful += successful
+ except Exception as e:
+ logger.error(ls.MG_REL_FLUSH_ERROR.format(pattern=pattern, error=e))
+ if first_error is None:
+ first_error = e
+ else:
+ for pattern, params_list in self._rel_groups.items():
+ try:
+ attempted, successful = self._flush_rel_pattern_group(
+ pattern, params_list
+ )
+ total_attempted += attempted
+ total_successful += successful
+ except Exception as e:
+ logger.error(ls.MG_REL_FLUSH_ERROR.format(pattern=pattern, error=e))
+ if first_error is None:
+ first_error = e
logger.info(
ls.MG_RELS_FLUSHED.format(
- total=len(self.relationship_buffer),
+ total=self._rel_count,
success=total_successful,
failed=total_attempted - total_successful,
)
)
- self.relationship_buffer.clear()
+ self._rel_count = 0
+ self._rel_groups.clear()
+
+ if first_error is not None:
+ raise first_error
def flush_all(self) -> None:
logger.info(ls.MG_FLUSH_START)
@@ -346,13 +562,14 @@ def flush_all(self) -> None:
def fetch_all(
self, query: str, params: dict[str, PropertyValue] | None = None
) -> list[ResultRow]:
- logger.debug(ls.MG_FETCH_QUERY.format(query=query, params=params))
- return self._execute_query(query, params)
+ bounded_query = _apply_memory_limit(query, settings.QUERY_MEMORY_LIMIT_MB)
+ logger.debug(ls.MG_FETCH_QUERY, query=bounded_query, params=params)
+ return self._execute_query(bounded_query, params)
def execute_write(
self, query: str, params: dict[str, PropertyValue] | None = None
) -> None:
- logger.debug(ls.MG_WRITE_QUERY.format(query=query, params=params))
+ logger.debug(ls.MG_WRITE_QUERY, query=query, params=params)
self._execute_query(query, params)
def export_graph_to_dict(self) -> GraphData:
diff --git a/codebase_rag/services/llm.py b/codebase_rag/services/llm.py
index 018ccc1af..970331f2f 100644
--- a/codebase_rag/services/llm.py
+++ b/codebase_rag/services/llm.py
@@ -1,14 +1,17 @@
from __future__ import annotations
+import re
+from pathlib import Path
from typing import TYPE_CHECKING
from loguru import logger
from pydantic_ai import Agent, DeferredToolRequests, Tool
+from pydantic_ai.agent import AgentRetries
from .. import constants as cs
from .. import exceptions as ex
from .. import logs as ls
-from ..config import ModelConfig, settings
+from ..config import ModelConfig, load_cgr_instructions, settings
from ..prompts import (
CYPHER_SYSTEM_PROMPT,
LOCAL_CYPHER_SYSTEM_PROMPT,
@@ -26,15 +29,88 @@ def _create_provider_model(config: ModelConfig) -> Model:
def _clean_cypher_response(response_text: str) -> str:
- query = response_text.strip().replace(cs.CYPHER_BACKTICK, "")
- if query.startswith(cs.CYPHER_PREFIX):
- query = query[len(cs.CYPHER_PREFIX) :].strip()
+ query = response_text.strip()
+
+ if "```" in query:
+ parts = query.split("```")
+ if len(parts) >= 3:
+ block = parts[1]
+ if block.lower().startswith("cypher"):
+ block = block[len("cypher") :]
+ query = block.strip()
+ else:
+ while "**" in query:
+ start = query.index("**")
+ end = query.find("**", start + 2)
+ if end == -1:
+ break
+ after = end + 2
+ if after < len(query) and query[after] == ":":
+ after += 1
+ query = query[:start] + query[after:].lstrip()
+ query = query.replace(cs.CYPHER_BACKTICK, "")
+ if query.lower().startswith(cs.CYPHER_PREFIX):
+ query = query[len(cs.CYPHER_PREFIX) :].strip()
+
if not query.endswith(cs.CYPHER_SEMICOLON):
query += cs.CYPHER_SEMICOLON
return query
+_COMMENT_OR_WS = r"(?:\s|//[^\n]*|/\*.*?\*/)+"
+
+
+def _build_keyword_pattern(keyword: str) -> re.Pattern[str]:
+ parts = keyword.split()
+ if len(parts) == 1:
+ return re.compile(rf"\b{re.escape(parts[0])}\b")
+ joined = _COMMENT_OR_WS.join(re.escape(p) for p in parts)
+ return re.compile(rf"\b{joined}\b", re.DOTALL)
+
+
+_CYPHER_DANGEROUS_PATTERNS: list[tuple[str, re.Pattern[str]]] = [
+ (kw, _build_keyword_pattern(kw)) for kw in cs.CYPHER_DANGEROUS_KEYWORDS
+]
+
+
+_VARLEN_PATTERN = re.compile(r"\[[^\]]*?\*([^\]]*)\]")
+_PROCEDURE_CALL_PATTERN = re.compile(r"\bCALL\s+([\w\.]+)", re.IGNORECASE)
+
+
+def _validate_cypher_read_only(query: str) -> None:
+ upper_query = query.upper()
+ for keyword, pattern in _CYPHER_DANGEROUS_PATTERNS:
+ if pattern.search(upper_query):
+ raise ex.LLMGenerationError(
+ ex.LLM_DANGEROUS_QUERY.format(keyword=keyword, query=query)
+ )
+
+
+def _validate_no_unbounded_paths(query: str) -> None:
+ for match in _VARLEN_PATTERN.finditer(query):
+ spec = match.group(1).strip()
+ if not spec:
+ raise ex.LLMGenerationError(ex.LLM_UNBOUNDED_PATH.format(query=query))
+ if ".." in spec:
+ upper = spec.split("..", 1)[1].lstrip()
+ if not upper or not upper[0].isdigit():
+ raise ex.LLMGenerationError(ex.LLM_UNBOUNDED_PATH.format(query=query))
+
+
+def _validate_call_procedures(query: str) -> None:
+ for match in _PROCEDURE_CALL_PATTERN.finditer(query):
+ name = match.group(1)
+ if not any(
+ name.startswith(prefix) for prefix in cs.CYPHER_ALLOWED_PROCEDURE_PREFIXES
+ ):
+ raise ex.LLMGenerationError(
+ ex.LLM_DISALLOWED_PROCEDURE.format(name=name, query=query)
+ )
+
+
class CypherGenerator:
+ __slots__ = ("agent",)
+
def __init__(self) -> None:
try:
config = settings.active_cypher_config
@@ -68,6 +144,9 @@ async def generate(self, natural_language_query: str) -> str:
)
query = _clean_cypher_response(result.output)
+ _validate_cypher_read_only(query)
+ _validate_no_unbounded_paths(query)
+ _validate_call_procedures(query)
logger.info(ls.CYPHER_GENERATED.format(query=query))
return query
except Exception as e:
@@ -75,18 +154,35 @@ async def generate(self, natural_language_query: str) -> str:
raise ex.LLMGenerationError(ex.LLM_GENERATION_FAILED.format(error=e)) from e
-def create_rag_orchestrator(tools: list[Tool]) -> Agent:
+def create_rag_orchestrator(
+ tools: list[Tool],
+ project_root: Path | None = None,
+ load_instructions: bool = True,
+ active_projects: list[str] | None = None,
+) -> tuple[Agent, str]:
try:
config = settings.active_orchestrator_config
llm = _create_provider_model(config)
- return Agent(
+ project_instructions = (
+ load_cgr_instructions(project_root) if load_instructions else None
+ )
+ system_prompt = build_rag_orchestrator_prompt(
+ tools,
+ project_instructions=project_instructions,
+ active_projects=active_projects,
+ )
+
+ agent = Agent(
model=llm,
- system_prompt=build_rag_orchestrator_prompt(tools),
+ system_prompt=system_prompt,
tools=tools,
- retries=settings.AGENT_RETRIES,
- output_retries=settings.ORCHESTRATOR_OUTPUT_RETRIES,
+ retries=AgentRetries(
+ tools=settings.AGENT_RETRIES,
+ output=settings.ORCHESTRATOR_OUTPUT_RETRIES,
+ ),
output_type=[str, DeferredToolRequests],
)
+ return agent, system_prompt
except Exception as e:
raise ex.LLMGenerationError(ex.LLM_INIT_ORCHESTRATOR.format(error=e)) from e
diff --git a/codebase_rag/services/protobuf_service.py b/codebase_rag/services/protobuf_service.py
index 7c5138c12..50de78eb9 100644
--- a/codebase_rag/services/protobuf_service.py
+++ b/codebase_rag/services/protobuf_service.py
@@ -22,6 +22,10 @@
cs.NodeLabel.EXTERNAL_PACKAGE: cs.ONEOF_EXTERNAL_PACKAGE,
cs.NodeLabel.MODULE_IMPLEMENTATION: cs.ONEOF_MODULE_IMPLEMENTATION,
cs.NodeLabel.MODULE_INTERFACE: cs.ONEOF_MODULE_INTERFACE,
+ cs.NodeLabel.INTERFACE: cs.ONEOF_INTERFACE,
+ cs.NodeLabel.ENUM: cs.ONEOF_ENUM,
+ cs.NodeLabel.TYPE: cs.ONEOF_TYPE,
+ cs.NodeLabel.UNION: cs.ONEOF_UNION,
}
ONEOF_FIELD_TO_LABEL: dict[str, cs.NodeLabel] = {
@@ -32,7 +36,13 @@
NAME_BASED_LABELS = frozenset({cs.NodeLabel.EXTERNAL_PACKAGE, cs.NodeLabel.PROJECT})
+_REL_TYPE_CACHE: dict = {}
+_MSG_CLASS_CACHE: dict[str, type | None] = {}
+
+
class ProtobufFileIngestor:
+ __slots__ = ("output_dir", "_nodes", "_relationships", "split_index")
+
def __init__(self, output_path: str, split_index: bool = False):
self.output_dir = Path(output_path)
self._nodes: dict[str, pb.Node] = {}
@@ -53,7 +63,11 @@ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
if not node_id or node_id in self._nodes:
return
- payload_message_class = getattr(pb, label, None)
+ if label in _MSG_CLASS_CACHE:
+ payload_message_class = _MSG_CLASS_CACHE[label]
+ else:
+ payload_message_class = getattr(pb, label, None)
+ _MSG_CLASS_CACHE[label] = payload_message_class
if not payload_message_class:
logger.warning(ls.PROTOBUF_NO_MESSAGE_CLASS.format(label=label))
return
@@ -88,42 +102,45 @@ def ensure_relationship_batch(
to_spec: tuple[str, str, PropertyValue],
properties: PropertyDict | None = None,
) -> None:
- rel = pb.Relationship()
+ if rel_type in _REL_TYPE_CACHE:
+ rel_type_enum = _REL_TYPE_CACHE[rel_type]
+ else:
+ resolved = getattr(pb.Relationship.RelationshipType, rel_type, None)
+ if resolved is None:
+ logger.warning(ls.PROTOBUF_UNKNOWN_REL_TYPE.format(rel_type=rel_type))
+ resolved = (
+ pb.Relationship.RelationshipType.RELATIONSHIP_TYPE_UNSPECIFIED
+ )
+ rel_type_enum = resolved
+ _REL_TYPE_CACHE[rel_type] = rel_type_enum
- rel_type_enum = getattr(pb.Relationship.RelationshipType, rel_type, None)
- if rel_type_enum is None:
- logger.warning(ls.PROTOBUF_UNKNOWN_REL_TYPE.format(rel_type=rel_type))
- rel_type_enum = (
- pb.Relationship.RelationshipType.RELATIONSHIP_TYPE_UNSPECIFIED
- )
- rel.type = rel_type_enum
+ from_label, _, from_val_raw = from_spec
+ to_label, _, to_val_raw = to_spec
- from_label, _, from_val = from_spec
- to_label, _, to_val = to_spec
+ from_val = str(from_val_raw) if from_val_raw is not None else ""
+ to_val = str(to_val_raw) if to_val_raw is not None else ""
- rel.source_id = str(from_val)
- rel.source_label = str(from_label)
- rel.target_id = str(to_val)
- rel.target_label = str(to_label)
+ unique_key = (from_val, rel_type_enum, to_val)
+ if unique_key in self._relationships:
+ if properties:
+ self._relationships[unique_key].properties.update(properties)
+ return
- if not rel.source_id.strip() or not rel.target_id.strip():
+ if not from_val.strip() or not to_val.strip():
logger.warning(
- ls.PROTOBUF_INVALID_REL.format(
- source_id=rel.source_id, target_id=rel.target_id
- )
+ ls.PROTOBUF_INVALID_REL.format(source_id=from_val, target_id=to_val)
)
return
+ rel = pb.Relationship()
+ rel.type = rel_type_enum
+ rel.source_id = from_val
+ rel.source_label = str(from_label)
+ rel.target_id = to_val
+ rel.target_label = str(to_label)
if properties:
rel.properties.update(properties)
-
- unique_key = (rel.source_id, rel.type, rel.target_id)
- if unique_key in self._relationships:
- if properties:
- existing_rel = self._relationships[unique_key]
- existing_rel.properties.update(properties)
- else:
- self._relationships[unique_key] = rel
+ self._relationships[unique_key] = rel
def _flush_joint(self) -> None:
index = pb.GraphCodeIndex()
diff --git a/codebase_rag/stack/__init__.py b/codebase_rag/stack/__init__.py
new file mode 100644
index 000000000..277a85f8a
--- /dev/null
+++ b/codebase_rag/stack/__init__.py
@@ -0,0 +1,21 @@
+from .manager import (
+ StackManager,
+ StackStatus,
+ daemon_down,
+ daemon_logs,
+ daemon_restart,
+ daemon_status,
+ daemon_up,
+ ensure_running,
+)
+
+__all__ = [
+ "StackManager",
+ "StackStatus",
+ "daemon_down",
+ "daemon_logs",
+ "daemon_restart",
+ "daemon_status",
+ "daemon_up",
+ "ensure_running",
+]
diff --git a/codebase_rag/stack/cli.py b/codebase_rag/stack/cli.py
new file mode 100644
index 000000000..5677ae2f0
--- /dev/null
+++ b/codebase_rag/stack/cli.py
@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+import sys
+
+import click
+from loguru import logger
+
+from .. import cli_help as ch
+from .manager import StackError, StackManager
+
+
+@click.group(help=ch.CMD_DAEMON_GROUP)
+def cli() -> None:
+ pass
+
+
+def _print_status(mgr: StackManager) -> None:
+ status = mgr.status()
+ click.echo(f"state: {status.state.value}")
+ click.echo(
+ f"memgraph: {status.memgraph_endpoint} (reachable={status.memgraph_reachable})"
+ )
+ click.echo(
+ f"qdrant: {status.qdrant_endpoint} (reachable={status.qdrant_reachable})"
+ )
+ click.echo(f"compose: {status.compose_file}")
+
+
+@cli.command("up", help=ch.CMD_DAEMON_UP)
+def up_cmd() -> None:
+ mgr = StackManager()
+ try:
+ mgr.ensure_running()
+ _print_status(mgr)
+ except StackError as e:
+ logger.error(str(e))
+ click.secho(str(e), fg="red", err=True)
+ sys.exit(1)
+
+
+@cli.command("down", help=ch.CMD_DAEMON_DOWN)
+def down_cmd() -> None:
+ mgr = StackManager()
+ try:
+ mgr.down()
+ click.echo("stopped")
+ except StackError as e:
+ logger.error(str(e))
+ click.secho(str(e), fg="red", err=True)
+ sys.exit(1)
+
+
+@cli.command("status", help=ch.CMD_DAEMON_STATUS)
+def status_cmd() -> None:
+ _print_status(StackManager())
+
+
+@cli.command("restart", help=ch.CMD_DAEMON_RESTART)
+def restart_cmd() -> None:
+ mgr = StackManager()
+ try:
+ mgr.restart()
+ mgr.wait_healthy()
+ _print_status(mgr)
+ except StackError as e:
+ logger.error(str(e))
+ click.secho(str(e), fg="red", err=True)
+ sys.exit(1)
+
+
+@cli.command("logs", help=ch.CMD_DAEMON_LOGS)
+@click.option("--follow", "-f", is_flag=True, help=ch.HELP_DAEMON_LOGS_FOLLOW)
+@click.option("--service", "-s", default=None, help=ch.HELP_DAEMON_LOGS_SERVICE)
+def logs_cmd(follow: bool, service: str | None) -> None:
+ mgr = StackManager()
+ try:
+ rc = mgr.logs(service=service, follow=follow)
+ if rc != 0:
+ sys.exit(rc)
+ except StackError as e:
+ logger.error(str(e))
+ click.secho(str(e), fg="red", err=True)
+ sys.exit(1)
diff --git a/codebase_rag/stack/constants.py b/codebase_rag/stack/constants.py
new file mode 100644
index 000000000..bb5d7b0ff
--- /dev/null
+++ b/codebase_rag/stack/constants.py
@@ -0,0 +1,51 @@
+from enum import StrEnum
+
+COMPOSE_PROJECT_NAME = "cgr"
+COMPOSE_FILENAME = "docker-compose.yaml"
+STATE_FILENAME = "state.json"
+
+DOCKER_BIN = "docker"
+DOCKER_COMPOSE_SUBCOMMAND = "compose"
+
+DEFAULT_HEALTH_TIMEOUT_S = 60.0
+DEFAULT_HEALTH_INTERVAL_S = 1.0
+DEFAULT_DOCKER_TIMEOUT_S = 120.0
+DEFAULT_STATUS_TIMEOUT_S = 10.0
+
+SERVICE_MEMGRAPH = "memgraph"
+SERVICE_QDRANT = "qdrant"
+SERVICE_LAB = "lab"
+
+
+class StackState(StrEnum):
+ RUNNING = "running"
+ PARTIAL = "partial"
+ STOPPED = "stopped"
+ UNKNOWN = "unknown"
+
+
+ERR_DOCKER_NOT_INSTALLED = (
+ "docker not found on PATH. Install Docker Desktop or the docker CLI."
+)
+ERR_DOCKER_DAEMON_DOWN = (
+ "docker is installed but the daemon is not responding. Start Docker and retry."
+)
+ERR_COMPOSE_NOT_AVAILABLE = "`docker compose` plugin not available. Install Docker Desktop v2+ or the compose plugin."
+ERR_STACK_START_FAILED = "Failed to bring stack up: {detail}"
+ERR_STACK_STOP_FAILED = "Failed to bring stack down: {detail}"
+ERR_STACK_NOT_HEALTHY = (
+ "Stack started but {service} did not become healthy within {timeout}s."
+)
+ERR_COMPOSE_FILE_MISSING = "Compose file not found at {path}."
+
+MSG_USING_COMPOSE_FILE = "Using compose file at {path}"
+MSG_STARTING_STACK = "Starting cgr stack..."
+MSG_STACK_HEALTHY = "Stack is healthy ({memgraph}, {qdrant})."
+MSG_STACK_ALREADY_RUNNING = "Stack already running."
+MSG_STOPPING_STACK = "Stopping cgr stack..."
+MSG_STACK_STOPPED = "Stack stopped."
+MSG_RESTARTING_STACK = "Restarting cgr stack..."
+MSG_RENDERING_COMPOSE = "Rendering compose file to {path}"
+MSG_WAITING_FOR_HEALTH = "Waiting for {service} on {host}:{port}..."
+
+PACKAGE_COMPOSE_RELATIVE = "../docker-compose.yaml"
diff --git a/codebase_rag/stack/health.py b/codebase_rag/stack/health.py
new file mode 100644
index 000000000..b5353374a
--- /dev/null
+++ b/codebase_rag/stack/health.py
@@ -0,0 +1,60 @@
+from __future__ import annotations
+
+import time
+import urllib.error
+import urllib.request
+
+import mgclient # ty: ignore[unresolved-import]
+
+from . import constants as cs
+
+
+def _bolt_reachable(host: str, port: int) -> bool:
+ try:
+ conn = mgclient.connect(host=host, port=port)
+ try:
+ cursor = conn.cursor()
+ cursor.execute("RETURN 1")
+ cursor.fetchall()
+ finally:
+ conn.close()
+ return True
+ except (mgclient.Error, OSError):
+ return False
+
+
+def _http_reachable(url: str, timeout: float = 1.5) -> bool:
+ try:
+ with urllib.request.urlopen(url, timeout=timeout) as resp: # noqa: S310
+ return 200 <= resp.status < 500
+ except (urllib.error.URLError, TimeoutError, OSError):
+ return False
+
+
+def wait_for_memgraph(
+ host: str,
+ port: int,
+ timeout: float = cs.DEFAULT_HEALTH_TIMEOUT_S,
+ interval: float = cs.DEFAULT_HEALTH_INTERVAL_S,
+) -> bool:
+ deadline = time.monotonic() + timeout
+ while time.monotonic() < deadline:
+ if _bolt_reachable(host, port):
+ return True
+ time.sleep(interval)
+ return False
+
+
+def wait_for_qdrant(
+ host: str,
+ port: int,
+ timeout: float = cs.DEFAULT_HEALTH_TIMEOUT_S,
+ interval: float = cs.DEFAULT_HEALTH_INTERVAL_S,
+) -> bool:
+ url = f"http://{host}:{port}/readyz"
+ deadline = time.monotonic() + timeout
+ while time.monotonic() < deadline:
+ if _http_reachable(url):
+ return True
+ time.sleep(interval)
+ return False
diff --git a/codebase_rag/stack/manager.py b/codebase_rag/stack/manager.py
new file mode 100644
index 000000000..95ffc155b
--- /dev/null
+++ b/codebase_rag/stack/manager.py
@@ -0,0 +1,262 @@
+from __future__ import annotations
+
+import shutil
+import subprocess
+from dataclasses import dataclass
+from pathlib import Path
+
+from loguru import logger
+
+from ..config import settings
+from . import constants as cs
+from .health import wait_for_memgraph, wait_for_qdrant
+
+
+class StackError(RuntimeError):
+ pass
+
+
+@dataclass
+class StackStatus:
+ state: cs.StackState
+ memgraph_reachable: bool
+ qdrant_reachable: bool
+ compose_file: Path
+ memgraph_endpoint: str
+ qdrant_endpoint: str
+
+
+class StackManager:
+ def __init__(
+ self,
+ home: Path | None = None,
+ package_compose: Path | None = None,
+ memgraph_host: str | None = None,
+ memgraph_port: int | None = None,
+ qdrant_host: str = "localhost",
+ qdrant_port: int = 6333,
+ project_name: str = cs.COMPOSE_PROJECT_NAME,
+ ) -> None:
+ self.home = (home or settings.CGR_HOME).expanduser()
+ self.package_compose = (
+ package_compose
+ or (Path(__file__).resolve().parent / cs.PACKAGE_COMPOSE_RELATIVE).resolve()
+ )
+ self.memgraph_host = memgraph_host or settings.MEMGRAPH_HOST
+ self.memgraph_port = memgraph_port or settings.MEMGRAPH_PORT
+ self.qdrant_host = qdrant_host
+ self.qdrant_port = qdrant_port
+ self.project_name = project_name
+
+ @property
+ def compose_file(self) -> Path:
+ return self.home / cs.COMPOSE_FILENAME
+
+ def ensure_home(self) -> None:
+ self.home.mkdir(parents=True, exist_ok=True)
+
+ def ensure_compose_file(self) -> Path:
+ self.ensure_home()
+ target = self.compose_file
+ if not target.exists():
+ if not self.package_compose.exists():
+ raise StackError(
+ cs.ERR_COMPOSE_FILE_MISSING.format(path=self.package_compose)
+ )
+ logger.info(cs.MSG_RENDERING_COMPOSE.format(path=target))
+ shutil.copyfile(self.package_compose, target)
+ return target
+
+ def check_docker(self) -> None:
+ if shutil.which(cs.DOCKER_BIN) is None:
+ raise StackError(cs.ERR_DOCKER_NOT_INSTALLED)
+ info = subprocess.run(
+ [cs.DOCKER_BIN, "info"],
+ capture_output=True,
+ text=True,
+ timeout=cs.DEFAULT_STATUS_TIMEOUT_S,
+ check=False,
+ )
+ if info.returncode != 0:
+ raise StackError(cs.ERR_DOCKER_DAEMON_DOWN)
+ compose = subprocess.run(
+ [cs.DOCKER_BIN, cs.DOCKER_COMPOSE_SUBCOMMAND, "version"],
+ capture_output=True,
+ text=True,
+ timeout=cs.DEFAULT_STATUS_TIMEOUT_S,
+ check=False,
+ )
+ if compose.returncode != 0:
+ raise StackError(cs.ERR_COMPOSE_NOT_AVAILABLE)
+
+ def _compose_cmd(self, *args: str) -> list[str]:
+ return [
+ cs.DOCKER_BIN,
+ cs.DOCKER_COMPOSE_SUBCOMMAND,
+ "-p",
+ self.project_name,
+ "-f",
+ str(self.compose_file),
+ *args,
+ ]
+
+ def up(self, timeout: float = cs.DEFAULT_DOCKER_TIMEOUT_S) -> None:
+ self.check_docker()
+ self.ensure_compose_file()
+ logger.info(cs.MSG_STARTING_STACK)
+ result = subprocess.run(
+ self._compose_cmd("up", "-d"),
+ capture_output=True,
+ text=True,
+ timeout=timeout,
+ check=False,
+ )
+ if result.returncode != 0:
+ raise StackError(
+ cs.ERR_STACK_START_FAILED.format(
+ detail=result.stderr.strip() or result.stdout.strip()
+ )
+ )
+
+ def down(self, timeout: float = cs.DEFAULT_DOCKER_TIMEOUT_S) -> None:
+ if not self.compose_file.exists():
+ return
+ if shutil.which(cs.DOCKER_BIN) is None:
+ raise StackError(cs.ERR_DOCKER_NOT_INSTALLED)
+ logger.info(cs.MSG_STOPPING_STACK)
+ result = subprocess.run(
+ self._compose_cmd("down"),
+ capture_output=True,
+ text=True,
+ timeout=timeout,
+ check=False,
+ )
+ if result.returncode != 0:
+ raise StackError(
+ cs.ERR_STACK_STOP_FAILED.format(
+ detail=result.stderr.strip() or result.stdout.strip()
+ )
+ )
+
+ def logs(
+ self,
+ service: str | None = None,
+ follow: bool = False,
+ tail: int | None = 200,
+ ) -> int:
+ if not self.compose_file.exists():
+ raise StackError(cs.ERR_COMPOSE_FILE_MISSING.format(path=self.compose_file))
+ args: list[str] = ["logs"]
+ if follow:
+ args.append("-f")
+ if tail is not None:
+ args.extend(["--tail", str(tail)])
+ if service:
+ args.append(service)
+ completed = subprocess.run(self._compose_cmd(*args), check=False)
+ return completed.returncode
+
+ def restart(self) -> None:
+ logger.info(cs.MSG_RESTARTING_STACK)
+ self.down()
+ self.up()
+
+ def wait_healthy(
+ self,
+ timeout: float = cs.DEFAULT_HEALTH_TIMEOUT_S,
+ ) -> None:
+ logger.info(
+ cs.MSG_WAITING_FOR_HEALTH.format(
+ service=cs.SERVICE_MEMGRAPH,
+ host=self.memgraph_host,
+ port=self.memgraph_port,
+ )
+ )
+ if not wait_for_memgraph(self.memgraph_host, self.memgraph_port, timeout):
+ raise StackError(
+ cs.ERR_STACK_NOT_HEALTHY.format(
+ service=cs.SERVICE_MEMGRAPH, timeout=timeout
+ )
+ )
+ logger.info(
+ cs.MSG_WAITING_FOR_HEALTH.format(
+ service=cs.SERVICE_QDRANT,
+ host=self.qdrant_host,
+ port=self.qdrant_port,
+ )
+ )
+ if not wait_for_qdrant(self.qdrant_host, self.qdrant_port, timeout):
+ raise StackError(
+ cs.ERR_STACK_NOT_HEALTHY.format(
+ service=cs.SERVICE_QDRANT, timeout=timeout
+ )
+ )
+
+ def status(self) -> StackStatus:
+ memgraph_ok = wait_for_memgraph(
+ self.memgraph_host, self.memgraph_port, timeout=0.1, interval=0.0
+ )
+ qdrant_ok = wait_for_qdrant(
+ self.qdrant_host, self.qdrant_port, timeout=0.1, interval=0.0
+ )
+ match (memgraph_ok, qdrant_ok):
+ case (True, True):
+ state = cs.StackState.RUNNING
+ case (False, False):
+ state = cs.StackState.STOPPED
+ case _:
+ state = cs.StackState.PARTIAL
+ return StackStatus(
+ state=state,
+ memgraph_reachable=memgraph_ok,
+ qdrant_reachable=qdrant_ok,
+ compose_file=self.compose_file,
+ memgraph_endpoint=f"{self.memgraph_host}:{self.memgraph_port}",
+ qdrant_endpoint=f"{self.qdrant_host}:{self.qdrant_port}",
+ )
+
+ def ensure_running(self) -> StackStatus:
+ current = self.status()
+ if current.state == cs.StackState.RUNNING:
+ logger.info(cs.MSG_STACK_ALREADY_RUNNING)
+ return current
+ self.up()
+ self.wait_healthy()
+ final = self.status()
+ logger.info(
+ cs.MSG_STACK_HEALTHY.format(
+ memgraph=final.memgraph_endpoint,
+ qdrant=final.qdrant_endpoint,
+ )
+ )
+ return final
+
+
+def ensure_running() -> StackStatus:
+ return StackManager().ensure_running()
+
+
+def daemon_up() -> StackStatus:
+ mgr = StackManager()
+ mgr.up()
+ mgr.wait_healthy()
+ return mgr.status()
+
+
+def daemon_down() -> None:
+ StackManager().down()
+
+
+def daemon_status() -> StackStatus:
+ return StackManager().status()
+
+
+def daemon_logs(service: str | None = None, follow: bool = False) -> int:
+ return StackManager().logs(service=service, follow=follow)
+
+
+def daemon_restart() -> StackStatus:
+ mgr = StackManager()
+ mgr.restart()
+ mgr.wait_healthy()
+ return mgr.status()
diff --git a/codebase_rag/tests/conftest.py b/codebase_rag/tests/conftest.py
index a22c1ede0..e3a4a19c1 100644
--- a/codebase_rag/tests/conftest.py
+++ b/codebase_rag/tests/conftest.py
@@ -8,14 +8,13 @@
from dataclasses import dataclass, field
from pathlib import Path
from typing import TYPE_CHECKING, Protocol, Self
-from unittest.mock import MagicMock
+from unittest.mock import MagicMock, call
import pytest
from loguru import logger
from codebase_rag.graph_updater import GraphUpdater
from codebase_rag.parser_loader import load_parsers
-from codebase_rag.services.graph_service import MemgraphIngestor
if TYPE_CHECKING:
pass # ty: ignore[unresolved-import]
@@ -89,6 +88,25 @@ def create_mock_node(
logger.remove()
+@pytest.fixture(autouse=True)
+def _disable_stack_autostart() -> Generator[None, None, None]:
+ from unittest.mock import patch
+
+ with patch("codebase_rag.cli._maybe_start_stack"):
+ yield
+
+
+@pytest.fixture(autouse=True)
+def _isolate_cgr_home(
+ tmp_path_factory: pytest.TempPathFactory, monkeypatch: pytest.MonkeyPatch
+) -> Generator[Path, None, None]:
+ from codebase_rag.config import settings
+
+ home = tmp_path_factory.mktemp("cgr-home-iso")
+ monkeypatch.setattr(settings, "CGR_HOME", home)
+ yield home
+
+
@pytest.fixture
def temp_repo() -> Generator[Path, None, None]:
"""Creates a temporary repository path for a test and cleans up afterward."""
@@ -97,10 +115,44 @@ def temp_repo() -> Generator[Path, None, None]:
shutil.rmtree(temp_dir)
+class _MockIngestor:
+ _TRACKED = (
+ "fetch_all",
+ "execute_write",
+ "ensure_node_batch",
+ "ensure_relationship_batch",
+ "flush_all",
+ )
+
+ def __init__(self) -> None:
+ self.fetch_all = MagicMock()
+ self.execute_write = MagicMock()
+ self.ensure_node_batch = MagicMock()
+ self.ensure_relationship_batch = MagicMock()
+ self.flush_all = MagicMock()
+ self._fallback = MagicMock()
+
+ def reset_mock(self) -> None:
+ for name in (*self._TRACKED, "_fallback"):
+ getattr(self, name).reset_mock()
+
+ @property
+ def method_calls(self) -> list:
+ result = []
+ for name in self._TRACKED:
+ mock_attr = self.__dict__[name]
+ for c in mock_attr.call_args_list:
+ result.append(getattr(call, name)(*c.args, **c.kwargs))
+ result.extend(self._fallback.method_calls)
+ return result
+
+ def __getattr__(self, name: str) -> MagicMock:
+ return getattr(self._fallback, name)
+
+
@pytest.fixture
-def mock_ingestor() -> MagicMock:
- """Provides a mocked MemgraphIngestor instance."""
- return MagicMock(spec=MemgraphIngestor)
+def mock_ingestor() -> _MockIngestor:
+ return _MockIngestor()
def run_updater(
diff --git a/codebase_rag/tests/fuzz_test_parsers.py b/codebase_rag/tests/fuzz_test_parsers.py
new file mode 100644
index 000000000..d9a608887
--- /dev/null
+++ b/codebase_rag/tests/fuzz_test_parsers.py
@@ -0,0 +1,20 @@
+import sys
+
+import atheris
+
+from codebase_rag.language_spec import (
+ get_language_for_extension,
+ get_language_spec,
+)
+
+
+def fuzz_language_spec(data):
+ fdp = atheris.FuzzedDataProvider(data)
+ extension = fdp.ConsumeUnicodeNoSurrogates(64)
+ get_language_spec(extension)
+ get_language_for_extension(extension)
+
+
+if __name__ == "__main__":
+ atheris.Setup(sys.argv, fuzz_language_spec)
+ atheris.Fuzz()
diff --git a/codebase_rag/tests/integration/test_cypher_queries.py b/codebase_rag/tests/integration/test_cypher_queries.py
index e01415daf..4e5ee30ba 100644
--- a/codebase_rag/tests/integration/test_cypher_queries.py
+++ b/codebase_rag/tests/integration/test_cypher_queries.py
@@ -11,11 +11,13 @@
CYPHER_FIND_BY_QUALIFIED_NAME,
CYPHER_GET_FUNCTION_SOURCE_LOCATION,
build_constraint_query,
+ build_dead_code_query,
build_merge_node_query,
build_merge_relationship_query,
build_nodes_by_ids_query,
wrap_with_unwind,
)
+from codebase_rag.types_defs import PropertyValue
if TYPE_CHECKING:
from codebase_rag.services.graph_service import MemgraphIngestor
@@ -343,6 +345,292 @@ def test_creates_calls_relationship_with_properties(
assert verify[0]["line"] == 42
+class TestBuildDeadCodeQueryUnit:
+ def test_include_tests_references_test_patterns(self) -> None:
+ query = build_dead_code_query(include_tests=True)
+
+ assert "$test_patterns" in query
+ assert "$project_prefix" in query
+ assert "$root_decorators" in query
+ assert "$entry_points" in query
+ assert "is_exported" in query
+ assert "CALLS*0.." in query
+ # (H) test functions are roots when tests are included
+ assert "n.path CONTAINS" in query
+
+ def test_exclude_tests_omits_test_function_roots(self) -> None:
+ query = build_dead_code_query(include_tests=False)
+
+ # (H) test functions are NOT roots when excluding tests ...
+ assert "n.path CONTAINS" not in query
+ # (H) ... but test_patterns still filters test modules out of the
+ # (H) module-load root clause so test-only code is not kept alive.
+ assert "$test_patterns" in query
+ assert "m.path CONTAINS" in query
+ assert "$project_prefix" in query
+
+ def test_module_load_callees_are_roots(self) -> None:
+ query = build_dead_code_query(include_tests=False)
+
+ # (H) a function called by a Module node runs at import, so it is a root
+ assert "Module" in query
+ assert "[:CALLS]-(" in query
+
+ def test_include_classes_adds_class_candidates(self) -> None:
+ with_classes = build_dead_code_query(include_tests=False, include_classes=True)
+ assert "Function|Method|Class" in with_classes
+ assert "INHERITS" in with_classes
+
+ without_classes = build_dead_code_query(
+ include_tests=False, include_classes=False
+ )
+ assert "Function|Method|Class" not in without_classes
+ assert "INHERITS" not in without_classes
+
+
+@pytest.mark.integration
+class TestBuildDeadCodeQueryIntegration:
+ def _seed(self, ingestor: MemgraphIngestor) -> None:
+ # (H) called -> live; orphan -> dead; handler is a @task root;
+ # (H) routed is a @app.route root calling routed_callee (decorators are
+ # (H) stored @-prefixed and dotted, exactly as the parser emits them);
+ # (H) test_runs is a test root that calls helper (so helper is live)
+ ingestor._execute_query(
+ "CREATE "
+ "(m:Module {qualified_name: 'proj.mod', path: 'proj/mod.py'}), "
+ "(entry:Function {qualified_name: 'proj.mod.main', name: 'main', "
+ " start_line: 1, end_line: 3, decorators: [], path: 'proj/mod.py'}), "
+ "(called:Function {qualified_name: 'proj.mod.called', name: 'called', "
+ " start_line: 5, end_line: 7, decorators: [], path: 'proj/mod.py'}), "
+ "(orphan:Function {qualified_name: 'proj.mod.orphan', name: 'orphan', "
+ " start_line: 9, end_line: 11, decorators: [], path: 'proj/mod.py'}), "
+ "(handler:Function {qualified_name: 'proj.mod.handler', name: 'handler', "
+ " start_line: 13, end_line: 15, decorators: ['@task'], path: 'proj/mod.py'}), "
+ "(routed:Function {qualified_name: 'proj.mod.routed', name: 'routed', "
+ " start_line: 21, end_line: 23, decorators: ['@app.route'], "
+ " path: 'proj/mod.py'}), "
+ "(routed_callee:Function {qualified_name: 'proj.mod.routed_callee', "
+ " name: 'routed_callee', start_line: 25, end_line: 27, decorators: [], "
+ " path: 'proj/mod.py'}), "
+ "(helper:Function {qualified_name: 'proj.mod.helper', name: 'helper', "
+ " start_line: 17, end_line: 19, decorators: [], path: 'proj/mod.py'}), "
+ "(testfn:Function {qualified_name: 'proj.tests.test_runs', "
+ " name: 'test_runs', start_line: 1, end_line: 4, decorators: [], "
+ " path: 'proj/tests/test_mod.py'}), "
+ "(entry)-[:CALLS]->(called), "
+ "(routed)-[:CALLS]->(routed_callee), "
+ "(testfn)-[:CALLS]->(helper)"
+ )
+
+ def _params(self, include_tests: bool) -> dict[str, PropertyValue]: # noqa: ARG002
+ # (H) test_patterns is always supplied; the query (built per include_tests)
+ # (H) decides whether it gates test-function roots or test-module filtering.
+ return {
+ "project_prefix": "proj.",
+ "root_decorators": ["task", "route"],
+ "entry_points": ["proj.mod.main"],
+ "test_patterns": ["test_", "_test", "conftest", "/tests/"],
+ }
+
+ def test_reports_only_the_orphan_with_tests_included(
+ self, memgraph_ingestor: MemgraphIngestor
+ ) -> None:
+ self._seed(memgraph_ingestor)
+
+ results = memgraph_ingestor._execute_query(
+ build_dead_code_query(include_tests=True), self._params(True)
+ )
+
+ names = {r["qualified_name"] for r in results}
+ assert names == {"proj.mod.orphan"}
+
+ def test_excluding_tests_reports_orphan_and_test_only_code(
+ self, memgraph_ingestor: MemgraphIngestor
+ ) -> None:
+ self._seed(memgraph_ingestor)
+
+ results = memgraph_ingestor._execute_query(
+ build_dead_code_query(include_tests=False), self._params(False)
+ )
+
+ names = {r["qualified_name"] for r in results}
+ # (H) without test roots, the test fn and its helper are no longer reachable
+ assert names == {
+ "proj.mod.orphan",
+ "proj.tests.test_runs",
+ "proj.mod.helper",
+ }
+
+ def test_returns_row_shape(self, memgraph_ingestor: MemgraphIngestor) -> None:
+ self._seed(memgraph_ingestor)
+
+ results = memgraph_ingestor._execute_query(
+ build_dead_code_query(include_tests=True), self._params(True)
+ )
+
+ assert len(results) == 1
+ row = results[0]
+ assert row["label"] == "Function"
+ assert row["name"] == "orphan"
+ assert row["start_line"] == 9
+ assert row["end_line"] == 11
+
+ def test_test_module_call_is_not_a_root_when_excluding_tests(
+ self, memgraph_ingestor: MemgraphIngestor
+ ) -> None:
+ # (H) a function reached only from a TEST module's top-level call must NOT
+ # (H) be kept alive when --no-include-tests, else test-only code hides as
+ # (H) live. The same call DOES keep it live when tests are included.
+ memgraph_ingestor._execute_query(
+ "CREATE "
+ "(tm:Module {qualified_name: 'proj.tests.test_x', "
+ " path: 'proj/tests/test_x.py'}), "
+ "(tool:Function {qualified_name: 'proj.mod.tool_only', "
+ " name: 'tool_only', start_line: 1, end_line: 2, decorators: [], "
+ " path: 'proj/mod.py'}), "
+ "(tm)-[:CALLS]->(tool)"
+ )
+ params: dict[str, PropertyValue] = {
+ "project_prefix": "proj.",
+ "root_decorators": [],
+ "entry_points": [],
+ "test_patterns": ["test_", "_test", "conftest", "/tests/"],
+ }
+
+ excluded = memgraph_ingestor._execute_query(
+ build_dead_code_query(include_tests=False), params
+ )
+ assert {r["qualified_name"] for r in excluded} == {"proj.mod.tool_only"}
+
+ included = memgraph_ingestor._execute_query(
+ build_dead_code_query(include_tests=True), params
+ )
+ assert {r["qualified_name"] for r in included} == set()
+
+ def test_class_candidates_when_classes_included(
+ self, memgraph_ingestor: MemgraphIngestor
+ ) -> None:
+ # (H) used is a module-load root that instantiates WithInit (INSTANTIATES
+ # (H) the class plus CALLS its __init__), NoInit (INSTANTIATES only, no
+ # (H) __init__) and Derived (INSTANTIATES; Derived INHERITS Base, so Base
+ # (H) is live too). Only DeadClass (and the orphan function) is unreachable.
+ memgraph_ingestor._execute_query(
+ "CREATE "
+ "(m:Module {qualified_name: 'proj.mod', path: 'proj/mod.py'}), "
+ "(used:Function {qualified_name: 'proj.mod.used', name: 'used', "
+ " start_line: 1, end_line: 2, decorators: [], path: 'proj/mod.py'}), "
+ "(orphan_fn:Function {qualified_name: 'proj.mod.orphan_fn', "
+ " name: 'orphan_fn', start_line: 4, end_line: 5, decorators: [], "
+ " path: 'proj/mod.py'}), "
+ "(wi:Class {qualified_name: 'proj.mod.WithInit', name: 'WithInit', "
+ " start_line: 7, end_line: 9, decorators: [], path: 'proj/mod.py'}), "
+ "(wii:Method {qualified_name: 'proj.mod.WithInit.__init__', "
+ " name: '__init__', start_line: 8, end_line: 9, decorators: [], "
+ " path: 'proj/mod.py'}), "
+ "(ni:Class {qualified_name: 'proj.mod.NoInit', name: 'NoInit', "
+ " start_line: 11, end_line: 12, decorators: [], path: 'proj/mod.py'}), "
+ "(base:Class {qualified_name: 'proj.mod.Base', name: 'Base', "
+ " start_line: 14, end_line: 15, decorators: [], path: 'proj/mod.py'}), "
+ "(der:Class {qualified_name: 'proj.mod.Derived', name: 'Derived', "
+ " start_line: 17, end_line: 18, decorators: [], path: 'proj/mod.py'}), "
+ "(dead:Class {qualified_name: 'proj.mod.DeadClass', name: 'DeadClass', "
+ " start_line: 20, end_line: 21, decorators: [], path: 'proj/mod.py'}), "
+ "(wi)-[:DEFINES_METHOD]->(wii), "
+ "(der)-[:INHERITS]->(base), "
+ "(m)-[:CALLS]->(used), "
+ "(used)-[:INSTANTIATES]->(wi), "
+ "(used)-[:CALLS]->(wii), "
+ "(used)-[:INSTANTIATES]->(ni), "
+ "(used)-[:INSTANTIATES]->(der)"
+ )
+ params: dict[str, PropertyValue] = {
+ "project_prefix": "proj.",
+ "root_decorators": [],
+ "entry_points": [],
+ "test_patterns": ["test_", "_test", "conftest", "/tests/"],
+ }
+
+ without_classes = memgraph_ingestor._execute_query(
+ build_dead_code_query(include_tests=False, include_classes=False), params
+ )
+ assert {r["qualified_name"] for r in without_classes} == {"proj.mod.orphan_fn"}
+
+ with_classes = memgraph_ingestor._execute_query(
+ build_dead_code_query(include_tests=False, include_classes=True), params
+ )
+ assert {r["qualified_name"] for r in with_classes} == {
+ "proj.mod.orphan_fn",
+ "proj.mod.DeadClass",
+ }
+
+ def test_subclass_only_base_is_reported_when_subclass_is_unreachable(
+ self, memgraph_ingestor: MemgraphIngestor
+ ) -> None:
+ # (H) Base is subclassed by Derived, but nothing instantiates Derived, so
+ # (H) the traversal never reaches Derived and therefore never reaches Base
+ # (H) via INHERITS. The whole dead cluster (both classes) is reported: a
+ # (H) base kept alive only by an unreachable subclass is itself dead.
+ # (H) Live is present purely so the query has a reachable root to anchor.
+ memgraph_ingestor._execute_query(
+ "CREATE "
+ "(m:Module {qualified_name: 'proj.mod', path: 'proj/mod.py'}), "
+ "(live:Class {qualified_name: 'proj.mod.Live', name: 'Live', "
+ " start_line: 1, end_line: 2, decorators: [], path: 'proj/mod.py'}), "
+ "(base:Class {qualified_name: 'proj.mod.Base', name: 'Base', "
+ " start_line: 4, end_line: 5, decorators: [], path: 'proj/mod.py'}), "
+ "(der:Class {qualified_name: 'proj.mod.Derived', name: 'Derived', "
+ " start_line: 7, end_line: 8, decorators: [], path: 'proj/mod.py'}), "
+ "(der)-[:INHERITS]->(base), "
+ "(m)-[:INSTANTIATES]->(live)"
+ )
+ params: dict[str, PropertyValue] = {
+ "project_prefix": "proj.",
+ "root_decorators": [],
+ "entry_points": [],
+ "test_patterns": ["test_", "_test", "conftest", "/tests/"],
+ }
+
+ with_classes = memgraph_ingestor._execute_query(
+ build_dead_code_query(include_tests=False, include_classes=True), params
+ )
+ assert {r["qualified_name"] for r in with_classes} == {
+ "proj.mod.Base",
+ "proj.mod.Derived",
+ }
+
+ def test_module_load_callee_is_a_root(
+ self, memgraph_ingestor: MemgraphIngestor
+ ) -> None:
+ # (H) a function called by a Module (e.g. `if __name__ == "__main__": main()`
+ # (H) or a bare decorator) runs at import, so it and its callees are live even
+ # (H) with no entry-point/decorator/export root.
+ memgraph_ingestor._execute_query(
+ "CREATE "
+ "(m:Module {qualified_name: 'proj.mod', path: 'proj/mod.py'}), "
+ "(main:Function {qualified_name: 'proj.mod.main', name: 'main', "
+ " start_line: 1, end_line: 2, decorators: [], path: 'proj/mod.py'}), "
+ "(used:Function {qualified_name: 'proj.mod.used', name: 'used', "
+ " start_line: 4, end_line: 5, decorators: [], path: 'proj/mod.py'}), "
+ "(orphan:Function {qualified_name: 'proj.mod.orphan', name: 'orphan', "
+ " start_line: 7, end_line: 8, decorators: [], path: 'proj/mod.py'}), "
+ "(m)-[:CALLS]->(main), "
+ "(main)-[:CALLS]->(used)"
+ )
+ params: dict[str, PropertyValue] = {
+ "project_prefix": "proj.",
+ "root_decorators": [],
+ "entry_points": [],
+ "test_patterns": ["test_", "_test", "conftest", "/tests/"],
+ }
+
+ results = memgraph_ingestor._execute_query(
+ build_dead_code_query(include_tests=False), params
+ )
+ names = {r["qualified_name"] for r in results}
+
+ assert names == {"proj.mod.orphan"}
+
+
@pytest.mark.integration
class TestBuildNodesByIdsQueryIntegration:
def test_fetches_nodes_by_ids(self, memgraph_ingestor: MemgraphIngestor) -> None:
diff --git a/codebase_rag/tests/integration/test_document_analyzer_integration.py b/codebase_rag/tests/integration/test_document_analyzer_integration.py
deleted file mode 100644
index b1cc7f9fb..000000000
--- a/codebase_rag/tests/integration/test_document_analyzer_integration.py
+++ /dev/null
@@ -1,219 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-
-from codebase_rag.constants import Provider
-from codebase_rag.tools.document_analyzer import (
- DocumentAnalyzer,
- create_document_analyzer_tool,
-)
-
-pytestmark = [pytest.mark.integration]
-
-
-@pytest.fixture
-def temp_test_repo(tmp_path: Path) -> Path:
- (tmp_path / "readme.txt").write_text(
- "This is a README file.\nIt contains important information.",
- encoding="utf-8",
- )
- (tmp_path / "code.py").write_text(
- "def hello():\n return 'Hello, World!'",
- encoding="utf-8",
- )
- (tmp_path / "data.json").write_text(
- '{"name": "test", "value": 42}',
- encoding="utf-8",
- )
- subdir = tmp_path / "docs"
- subdir.mkdir()
- (subdir / "manual.txt").write_text(
- "User Manual\n\n1. Getting Started\n2. Configuration",
- encoding="utf-8",
- )
- return tmp_path
-
-
-@pytest.fixture
-def mock_settings() -> MagicMock:
- settings = MagicMock()
- settings.active_orchestrator_config.provider = Provider.GOOGLE
- settings.active_orchestrator_config.provider_type = "api"
- settings.active_orchestrator_config.api_key = "test-api-key"
- settings.active_orchestrator_config.model_id = "gemini-1.5-flash"
- return settings
-
-
-@pytest.fixture
-def mock_genai_client() -> MagicMock:
- client = MagicMock()
- response = MagicMock()
- response.text = "This is an analysis of the document."
- client.models.generate_content.return_value = response
- return client
-
-
-@pytest.fixture
-def analyzer_with_mock(
- temp_test_repo: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
-) -> DocumentAnalyzer:
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- return DocumentAnalyzer(str(temp_test_repo))
-
-
-class TestDocumentAnalyzerIntegration:
- def test_analyze_text_file(
- self,
- analyzer_with_mock: DocumentAnalyzer,
- mock_genai_client: MagicMock,
- ) -> None:
- result = analyzer_with_mock.analyze("readme.txt", "What is this file about?")
- assert "analysis" in result.lower()
- mock_genai_client.models.generate_content.assert_called_once()
-
- def test_analyze_code_file(
- self,
- analyzer_with_mock: DocumentAnalyzer,
- mock_genai_client: MagicMock,
- ) -> None:
- result = analyzer_with_mock.analyze("code.py", "What does this code do?")
- assert "analysis" in result.lower()
-
- def test_analyze_json_file(
- self,
- analyzer_with_mock: DocumentAnalyzer,
- mock_genai_client: MagicMock,
- ) -> None:
- result = analyzer_with_mock.analyze("data.json", "What data is in this file?")
- assert "analysis" in result.lower()
-
- def test_analyze_nested_file(
- self,
- analyzer_with_mock: DocumentAnalyzer,
- mock_genai_client: MagicMock,
- ) -> None:
- result = analyzer_with_mock.analyze("docs/manual.txt", "Summarize this manual")
- assert "analysis" in result.lower()
-
- def test_analyze_nonexistent_file(
- self,
- analyzer_with_mock: DocumentAnalyzer,
- ) -> None:
- result = analyzer_with_mock.analyze("nonexistent.txt", "What is this?")
- assert "error" in result.lower()
- assert "not found" in result.lower()
-
- def test_analyze_path_traversal_blocked(
- self,
- analyzer_with_mock: DocumentAnalyzer,
- ) -> None:
- result = analyzer_with_mock.analyze("../../../etc/passwd", "What is this?")
- assert "security" in result.lower()
-
-
-class TestDocumentAnalyzerToolIntegration:
- def test_tool_analyzes_file(
- self,
- temp_test_repo: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
- ) -> None:
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_test_repo))
- tool = create_document_analyzer_tool(analyzer)
- result = tool.function(
- file_path="readme.txt",
- question="What is in this file?",
- )
- assert "analysis" in result.lower()
-
- def test_tool_handles_error(
- self,
- temp_test_repo: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
- ) -> None:
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_test_repo))
- tool = create_document_analyzer_tool(analyzer)
- result = tool.function(
- file_path="missing.txt",
- question="What is this?",
- )
- assert "error" in result.lower()
-
-
-class TestDocumentAnalyzerWithDifferentProviders:
- def test_unsupported_provider_returns_error(
- self,
- temp_test_repo: Path,
- ) -> None:
- mock_settings = MagicMock()
- mock_settings.active_orchestrator_config.provider = "anthropic"
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- analyzer = DocumentAnalyzer(str(temp_test_repo))
- result = analyzer.analyze("readme.txt", "What is this?")
- assert "not supported" in result.lower()
-
-
-class TestDocumentAnalyzerResponseHandling:
- def test_handles_response_with_candidates(
- self,
- temp_test_repo: Path,
- mock_settings: MagicMock,
- ) -> None:
- mock_client = MagicMock()
- response = MagicMock()
- response.text = None
- candidate = MagicMock()
- part = MagicMock()
- part.text = "Analysis from candidate"
- candidate.content.parts = [part]
- response.candidates = [candidate]
- mock_client.models.generate_content.return_value = response
-
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_test_repo))
- result = analyzer.analyze("readme.txt", "What is this?")
- assert result == "Analysis from candidate"
-
- def test_handles_empty_response(
- self,
- temp_test_repo: Path,
- mock_settings: MagicMock,
- ) -> None:
- mock_client = MagicMock()
- response = MagicMock()
- response.text = None
- response.candidates = None
- mock_client.models.generate_content.return_value = response
-
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_test_repo))
- result = analyzer.analyze("readme.txt", "What is this?")
- assert "no" in result.lower() and "content" in result.lower()
diff --git a/codebase_rag/tests/integration/test_incremental_external_prune_e2e.py b/codebase_rag/tests/integration/test_incremental_external_prune_e2e.py
new file mode 100644
index 000000000..2a392d98c
--- /dev/null
+++ b/codebase_rag/tests/integration/test_incremental_external_prune_e2e.py
@@ -0,0 +1,57 @@
+# (H) End-to-end (real Memgraph) verification that an incremental rebuild prunes
+# (H) external import-target Module nodes that are no longer imported by anyone,
+# (H) e.g. an imported name renamed on a subsequent index.
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+
+import pytest
+
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+
+if TYPE_CHECKING:
+ from codebase_rag.services.graph_service import MemgraphIngestor
+
+pytestmark = [pytest.mark.integration]
+
+
+def _index(ingestor: MemgraphIngestor, project_path: Path, force: bool) -> None:
+ parsers, queries = load_parsers()
+ GraphUpdater(
+ ingestor=ingestor,
+ repo_path=project_path,
+ parsers=parsers,
+ queries=queries,
+ project_name="proj",
+ ).run(force=force)
+
+
+def _external_module_qns(ingestor: MemgraphIngestor) -> set[str]:
+ rows = ingestor.fetch_all(
+ "MATCH (m:Module) WHERE m.is_external = true RETURN m.qualified_name AS qn"
+ )
+ return {r["qn"] for r in rows if r.get("qn")}
+
+
+def test_incremental_rebuild_prunes_orphaned_external_module(
+ memgraph_ingestor: MemgraphIngestor, tmp_path: Path
+) -> None:
+ project = tmp_path / "proj"
+ project.mkdir()
+ (project / "__init__.py").touch()
+ client = project / "client.py"
+
+ client.write_text("from extlib import old_thing\n\nuse = old_thing\n")
+ _index(memgraph_ingestor, project, force=True)
+
+ before = _external_module_qns(memgraph_ingestor)
+ assert any(qn.endswith(".old_thing") for qn in before), before
+
+ client.write_text("from extlib import new_thing\n\nuse = new_thing\n")
+ _index(memgraph_ingestor, project, force=False)
+
+ after = _external_module_qns(memgraph_ingestor)
+ assert not any(qn.endswith(".old_thing") for qn in after), after
+ assert any(qn.endswith(".new_thing") for qn in after), after
diff --git a/codebase_rag/tests/integration/test_node_label_e2e.py b/codebase_rag/tests/integration/test_node_label_e2e.py
index f61792588..4fb10083a 100644
--- a/codebase_rag/tests/integration/test_node_label_e2e.py
+++ b/codebase_rag/tests/integration/test_node_label_e2e.py
@@ -16,8 +16,6 @@
SKIP_GO = "Go is in development status"
SKIP_SCALA = "Scala is in development status"
-SKIP_CSHARP = "C# is in development status"
-SKIP_PHP = "PHP is in development status"
PYTHON_CODE = """\
@@ -233,29 +231,6 @@ class MyCppClass {
}
"""
-CSHARP_CODE = """\
-public class MyCSharpClass {
- private int value;
-
- public MyCSharpClass() {
- this.value = 0;
- }
-
- public int GetValue() {
- return this.value;
- }
-}
-
-public interface IMyInterface {
- void DoSomething();
-}
-
-public enum Status {
- Active,
- Inactive
-}
-"""
-
PHP_CODE = """\
Path:
return project
-@pytest.fixture
-def csharp_project(tmp_path: Path) -> Path:
- project = tmp_path / "csharp_project"
- project.mkdir()
- (project / "Example.cs").write_text(CSHARP_CODE, encoding="utf-8")
- return project
-
-
@pytest.fixture
def php_project(tmp_path: Path) -> Path:
project = tmp_path / "php_project"
@@ -617,29 +584,29 @@ def test_rust_creates_function_nodes(
func_names = {n["name"] for n in functions}
assert "standalone_fn" in func_names
- def test_rust_creates_class_nodes_for_enums(
+ def test_rust_creates_enum_nodes_for_enums(
self, memgraph_ingestor: MemgraphIngestor, rust_project: Path
) -> None:
index_project(memgraph_ingestor, rust_project)
labels = get_node_labels(memgraph_ingestor)
- assert NodeLabel.CLASS.value in labels
+ assert NodeLabel.ENUM.value in labels
- classes = get_nodes_by_label(memgraph_ingestor, NodeLabel.CLASS.value)
- class_names = {n["name"] for n in classes}
- assert "Status" in class_names
+ enums = get_nodes_by_label(memgraph_ingestor, NodeLabel.ENUM.value)
+ enum_names = {n["name"] for n in enums}
+ assert "Status" in enum_names
- def test_rust_creates_class_nodes_for_traits(
+ def test_rust_creates_interface_nodes_for_traits(
self, memgraph_ingestor: MemgraphIngestor, rust_project: Path
) -> None:
index_project(memgraph_ingestor, rust_project)
labels = get_node_labels(memgraph_ingestor)
- assert NodeLabel.CLASS.value in labels
+ assert NodeLabel.INTERFACE.value in labels
- classes = get_nodes_by_label(memgraph_ingestor, NodeLabel.CLASS.value)
- class_names = {n["name"] for n in classes}
- assert "MyTrait" in class_names
+ interfaces = get_nodes_by_label(memgraph_ingestor, NodeLabel.INTERFACE.value)
+ interface_names = {n["name"] for n in interfaces}
+ assert "MyTrait" in interface_names
@pytest.mark.skip(reason=SKIP_GO)
@@ -825,46 +792,6 @@ def test_cpp_creates_module_implementation_nodes(
assert "mymodule_impl" in module_names
-@pytest.mark.skip(reason=SKIP_CSHARP)
-class TestCSharpNodeLabels:
- def test_csharp_creates_class_nodes(
- self, memgraph_ingestor: MemgraphIngestor, csharp_project: Path
- ) -> None:
- index_project(memgraph_ingestor, csharp_project)
-
- labels = get_node_labels(memgraph_ingestor)
- assert NodeLabel.CLASS.value in labels
-
- classes = get_nodes_by_label(memgraph_ingestor, NodeLabel.CLASS.value)
- class_names = {n["name"] for n in classes}
- assert "MyCSharpClass" in class_names
-
- def test_csharp_creates_interface_nodes(
- self, memgraph_ingestor: MemgraphIngestor, csharp_project: Path
- ) -> None:
- index_project(memgraph_ingestor, csharp_project)
-
- labels = get_node_labels(memgraph_ingestor)
- assert NodeLabel.INTERFACE.value in labels
-
- interfaces = get_nodes_by_label(memgraph_ingestor, NodeLabel.INTERFACE.value)
- interface_names = {n["name"] for n in interfaces}
- assert "IMyInterface" in interface_names
-
- def test_csharp_creates_enum_nodes(
- self, memgraph_ingestor: MemgraphIngestor, csharp_project: Path
- ) -> None:
- index_project(memgraph_ingestor, csharp_project)
-
- labels = get_node_labels(memgraph_ingestor)
- assert NodeLabel.ENUM.value in labels
-
- enums = get_nodes_by_label(memgraph_ingestor, NodeLabel.ENUM.value)
- enum_names = {n["name"] for n in enums}
- assert "Status" in enum_names
-
-
-@pytest.mark.skip(reason=SKIP_PHP)
class TestPhpNodeLabels:
def test_php_creates_class_nodes(
self, memgraph_ingestor: MemgraphIngestor, php_project: Path
@@ -938,8 +865,7 @@ def test_lua_creates_function_nodes(
("scala_project", SKIP_SCALA),
("java_project", None),
("cpp_project", None),
- ("csharp_project", SKIP_CSHARP),
- ("php_project", SKIP_PHP),
+ ("php_project", None),
("lua_project", None),
]
diff --git a/codebase_rag/tests/integration/test_shell_command_integration.py b/codebase_rag/tests/integration/test_shell_command_integration.py
index c5fda3f68..47391b6c0 100644
--- a/codebase_rag/tests/integration/test_shell_command_integration.py
+++ b/codebase_rag/tests/integration/test_shell_command_integration.py
@@ -1,5 +1,6 @@
from __future__ import annotations
+import shutil
from pathlib import Path
from unittest.mock import MagicMock
@@ -11,6 +12,8 @@
create_shell_command_tool,
)
+_HAS_RG = shutil.which("rg") is not None
+
pytestmark = [pytest.mark.anyio, pytest.mark.integration]
@@ -112,6 +115,7 @@ async def test_rm_removes_file(
assert result.return_code == 0
assert not (temp_test_repo / "file2.py").exists()
+ @pytest.mark.skipif(not _HAS_RG, reason="rg (ripgrep) not installed")
async def test_rg_searches_content(self, shell_commander: ShellCommander) -> None:
result = await shell_commander.execute("rg hello file2.py")
assert "hello" in result.stdout or result.return_code == 0
@@ -199,6 +203,7 @@ async def test_ls_pipe_head(self, shell_commander: ShellCommander) -> None:
lines = result.stdout.strip().split("\n")
assert len(lines) <= 2
+ @pytest.mark.skipif(not _HAS_RG, reason="rg (ripgrep) not installed")
async def test_cat_pipe_rg(
self, shell_commander: ShellCommander, temp_test_repo: Path
) -> None:
@@ -217,6 +222,7 @@ async def test_echo_pipe_wc(self, shell_commander: ShellCommander) -> None:
assert result.return_code == 0
assert "3" in result.stdout
+ @pytest.mark.skipif(not _HAS_RG, reason="rg (ripgrep) not installed")
async def test_find_pipe_rg_pipe_wc(self, shell_commander: ShellCommander) -> None:
result = await shell_commander.execute("find . -name '*.py' | rg py | wc -l")
assert result.return_code == 0
diff --git a/codebase_rag/tests/integration/test_tool_calling.py b/codebase_rag/tests/integration/test_tool_calling.py
index 0d7c14aaa..15c524275 100644
--- a/codebase_rag/tests/integration/test_tool_calling.py
+++ b/codebase_rag/tests/integration/test_tool_calling.py
@@ -76,10 +76,17 @@ def log_message_history(messages: list[ModelMessage], label: str) -> None:
async def run_agent_test(
agent: Agent, prompt: str, tracker: ToolCallTracker, label: str
) -> tuple[list[str], list[str]]:
+ from pydantic_ai.exceptions import ModelHTTPError
+
tracker.clear()
logger.info(f"\n{'#' * 60}\nRunning: {label}\nPrompt: {prompt}\n{'#' * 60}")
- result = await agent.run(prompt)
+ try:
+ result = await agent.run(prompt)
+ except ModelHTTPError as e:
+ if e.status_code in (401, 403):
+ pytest.skip(f"Live API rejected credentials ({e.status_code}); skipping.")
+ raise
messages = result.all_messages()
log_message_history(messages, label)
@@ -107,12 +114,30 @@ def tracking_tools(tracker: ToolCallTracker) -> list[Tool]:
return create_tracking_tools(tracker)
+def _api_key_configured() -> bool:
+ from codebase_rag.config import settings
+
+ config = settings.active_orchestrator_config
+ key = config.api_key
+ if not key or not key.strip():
+ return False
+ if key.startswith("op://"):
+ return False
+ return True
+
+
@pytest.fixture(scope="module")
def agent(tracking_tools: list[Tool]) -> Agent:
+ if not _api_key_configured():
+ pytest.skip(
+ "Live orchestrator API key not resolved "
+ "(unset or unresolved op:// reference); skipping live API integration."
+ )
try:
- return create_rag_orchestrator(tracking_tools)
+ rag_agent, _ = create_rag_orchestrator(tracking_tools)
+ return rag_agent
except Exception as e:
- pytest.skip(f"Ollama server not available: {e}")
+ pytest.skip(f"Orchestrator unavailable: {e}")
PARALLEL_PROMPT = """Execute ALL of these tasks in parallel, not sequentially:
diff --git a/codebase_rag/tests/test_absolute_path.py b/codebase_rag/tests/test_absolute_path.py
new file mode 100644
index 000000000..ede90839e
--- /dev/null
+++ b/codebase_rag/tests/test_absolute_path.py
@@ -0,0 +1,317 @@
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.tests.conftest import get_nodes, run_updater
+
+TS_CODE = (
+ "interface Greeter {\n"
+ " greet(): string;\n"
+ "}\n\n"
+ "enum Direction {\n"
+ " Up = 'UP',\n"
+ " Down = 'DOWN',\n"
+ "}\n\n"
+ "class MyGreeter implements Greeter {\n"
+ " greet(): string { return 'hi'; }\n"
+ "}\n"
+)
+
+CPP_MODULE_INTERFACE = "export module mymod;\nexport int add(int a, int b);\n"
+
+CPP_MODULE_IMPL = "module mymod;\nint add(int a, int b) { return a + b; }\n"
+
+
+@pytest.fixture(scope="module")
+def parsers_and_queries() -> tuple:
+ return load_parsers()
+
+
+@pytest.fixture
+def python_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "abs_path_test"
+ project_path.mkdir()
+
+ pkg_dir = project_path / "mypkg"
+ pkg_dir.mkdir()
+ (pkg_dir / "__init__.py").write_text("")
+
+ (pkg_dir / "mymodule.py").write_text(
+ "class MyClass:\n"
+ " def my_method(self):\n"
+ " pass\n"
+ "\n"
+ "def my_function():\n"
+ " pass\n"
+ )
+
+ misc_dir = project_path / "misc"
+ misc_dir.mkdir()
+ (misc_dir / "notes.txt").write_text("not a package")
+
+ (project_path / "standalone.py").write_text("def standalone_func():\n pass\n")
+
+ return project_path
+
+
+class TestAbsolutePathOnNodes:
+ def test_file_nodes_have_absolute_path(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ file_nodes = get_nodes(mock_ingestor, cs.NodeLabel.FILE)
+ assert len(file_nodes) > 0
+ for node_call in file_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ abs_path = props[cs.KEY_ABSOLUTE_PATH]
+ assert Path(abs_path).is_absolute()
+ assert abs_path == Path(abs_path).resolve().as_posix()
+
+ def test_module_nodes_have_absolute_path(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ module_nodes = get_nodes(mock_ingestor, cs.NodeLabel.MODULE)
+ internal_modules = [c for c in module_nodes if not c[0][1].get("is_external")]
+ assert len(internal_modules) > 0
+ for node_call in internal_modules:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ abs_path = props[cs.KEY_ABSOLUTE_PATH]
+ assert Path(abs_path).is_absolute()
+
+ def test_package_nodes_have_absolute_path(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ package_nodes = get_nodes(mock_ingestor, cs.NodeLabel.PACKAGE)
+ assert len(package_nodes) > 0
+ for node_call in package_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ abs_path = props[cs.KEY_ABSOLUTE_PATH]
+ assert Path(abs_path).is_absolute()
+
+ def test_function_nodes_have_absolute_path(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ func_nodes = get_nodes(mock_ingestor, cs.NodeLabel.FUNCTION)
+ assert len(func_nodes) > 0
+ for node_call in func_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ assert cs.KEY_PATH in props
+ abs_path = props[cs.KEY_ABSOLUTE_PATH]
+ assert Path(abs_path).is_absolute()
+
+ def test_class_nodes_have_absolute_path(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ class_nodes = get_nodes(mock_ingestor, cs.NodeLabel.CLASS)
+ assert len(class_nodes) > 0
+ for node_call in class_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ assert cs.KEY_PATH in props
+ abs_path = props[cs.KEY_ABSOLUTE_PATH]
+ assert Path(abs_path).is_absolute()
+
+ def test_method_nodes_have_absolute_path(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ method_nodes = get_nodes(mock_ingestor, cs.NodeLabel.METHOD)
+ assert len(method_nodes) > 0
+ for node_call in method_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ assert cs.KEY_PATH in props
+ abs_path = props[cs.KEY_ABSOLUTE_PATH]
+ assert Path(abs_path).is_absolute()
+
+ def test_folder_nodes_have_absolute_path(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ folder_nodes = get_nodes(mock_ingestor, cs.NodeLabel.FOLDER)
+ assert len(folder_nodes) > 0
+ for node_call in folder_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ abs_path = props[cs.KEY_ABSOLUTE_PATH]
+ assert Path(abs_path).is_absolute()
+
+ def test_absolute_path_matches_resolved_file(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ module_nodes = get_nodes(mock_ingestor, cs.NodeLabel.MODULE)
+ mymodule_nodes = [
+ c for c in module_nodes if c[0][1].get(cs.KEY_NAME) == "mymodule.py"
+ ]
+ assert len(mymodule_nodes) == 1
+ props = mymodule_nodes[0][0][1]
+ expected = (python_project / "mypkg" / "mymodule.py").resolve().as_posix()
+ assert props[cs.KEY_ABSOLUTE_PATH] == expected
+
+ def test_absolute_path_is_posix_format(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ file_nodes = get_nodes(mock_ingestor, cs.NodeLabel.FILE)
+ for node_call in file_nodes:
+ abs_path = node_call[0][1][cs.KEY_ABSOLUTE_PATH]
+ assert "\\" not in abs_path
+
+ def test_project_node_has_no_absolute_path(
+ self,
+ python_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.PYTHON not in parsers_and_queries[0]:
+ pytest.skip("Python parser not available")
+ run_updater(python_project, mock_ingestor)
+ project_nodes = get_nodes(mock_ingestor, cs.NodeLabel.PROJECT)
+ assert len(project_nodes) > 0
+ for node_call in project_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH not in props
+
+
+@pytest.fixture
+def ts_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "ts_abs_test"
+ project_path.mkdir()
+ (project_path / "types.ts").write_text(TS_CODE)
+ return project_path
+
+
+class TestTypeScriptAbsolutePath:
+ def test_interface_nodes_have_absolute_path(
+ self,
+ ts_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.TS not in parsers_and_queries[0]:
+ pytest.skip("TypeScript parser not available")
+ run_updater(ts_project, mock_ingestor)
+ interface_nodes = get_nodes(mock_ingestor, cs.NodeLabel.INTERFACE)
+ assert len(interface_nodes) > 0
+ for node_call in interface_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ assert Path(props[cs.KEY_ABSOLUTE_PATH]).is_absolute()
+
+ def test_enum_nodes_have_absolute_path(
+ self,
+ ts_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.TS not in parsers_and_queries[0]:
+ pytest.skip("TypeScript parser not available")
+ run_updater(ts_project, mock_ingestor)
+ enum_nodes = get_nodes(mock_ingestor, cs.NodeLabel.ENUM)
+ assert len(enum_nodes) > 0
+ for node_call in enum_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ assert Path(props[cs.KEY_ABSOLUTE_PATH]).is_absolute()
+
+
+@pytest.fixture
+def cpp_module_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "cpp_abs_test"
+ project_path.mkdir()
+ (project_path / "mymod.cppm").write_text(CPP_MODULE_INTERFACE)
+ (project_path / "mymod_impl.cpp").write_text(CPP_MODULE_IMPL)
+ return project_path
+
+
+class TestCppModuleAbsolutePath:
+ def test_module_interface_nodes_have_absolute_path(
+ self,
+ cpp_module_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.CPP not in parsers_and_queries[0]:
+ pytest.skip("C++ parser not available")
+ run_updater(cpp_module_project, mock_ingestor)
+ mi_nodes = get_nodes(mock_ingestor, cs.NodeLabel.MODULE_INTERFACE)
+ if len(mi_nodes) == 0:
+ pytest.skip("No ModuleInterface nodes produced")
+ for node_call in mi_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ assert Path(props[cs.KEY_ABSOLUTE_PATH]).is_absolute()
+
+ def test_module_implementation_nodes_have_absolute_path(
+ self,
+ cpp_module_project: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ if cs.SupportedLanguage.CPP not in parsers_and_queries[0]:
+ pytest.skip("C++ parser not available")
+ run_updater(cpp_module_project, mock_ingestor)
+ mi_nodes = get_nodes(mock_ingestor, cs.NodeLabel.MODULE_IMPLEMENTATION)
+ if len(mi_nodes) == 0:
+ pytest.skip("No ModuleImplementation nodes produced")
+ for node_call in mi_nodes:
+ props = node_call[0][1]
+ assert cs.KEY_ABSOLUTE_PATH in props
+ assert Path(props[cs.KEY_ABSOLUTE_PATH]).is_absolute()
diff --git a/codebase_rag/tests/test_abstract_method_override_resolution.py b/codebase_rag/tests/test_abstract_method_override_resolution.py
new file mode 100644
index 000000000..582496d24
--- /dev/null
+++ b/codebase_rag/tests/test_abstract_method_override_resolution.py
@@ -0,0 +1,106 @@
+# (H) L3 finding from the evals/ harness: a mixin declares an @abstractmethod stub
+# (H) for a method a sibling mixin implements; self.method() dispatches to the
+# (H) concrete sibling at runtime. cgr's ambiguous-name tiebreak preferred the
+# (H) same-module abstract stub by import distance. A concrete implementation must
+# (H) win over an abstract stub of the same name.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "pkg"
+
+READER_SRC = """from abc import abstractmethod
+
+
+class ReaderMixin:
+ @abstractmethod
+ def parse(self) -> str: ...
+
+ def read(self) -> str:
+ return self.parse()
+"""
+
+PARSER_SRC = """class ParserMixin:
+ def parse(self) -> str:
+ return "parsed"
+"""
+
+ENGINE_SRC = """from pkg.reader import ReaderMixin
+from pkg.parser import ParserMixin
+
+
+class Engine(ReaderMixin, ParserMixin):
+ pass
+"""
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ pkg = tmp_path / "pkg"
+ pkg.mkdir()
+ (pkg / "__init__.py").write_text("")
+ (pkg / "reader.py").write_text(READER_SRC)
+ (pkg / "parser.py").write_text(PARSER_SRC)
+ (pkg / "engine.py").write_text(ENGINE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=pkg,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestAbstractMethodOverrideResolution:
+ def test_self_call_resolves_to_concrete_sibling_not_abstract_stub(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "pkg.reader.ReaderMixin.read",
+ "pkg.parser.ParserMixin.parse",
+ ) in calls, calls
+
+ def test_abstract_stub_is_not_the_call_target(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "pkg.reader.ReaderMixin.read",
+ "pkg.reader.ReaderMixin.parse",
+ ) not in calls, calls
diff --git a/codebase_rag/tests/test_anthropic_token_counter.py b/codebase_rag/tests/test_anthropic_token_counter.py
new file mode 100644
index 000000000..43ff172a1
--- /dev/null
+++ b/codebase_rag/tests/test_anthropic_token_counter.py
@@ -0,0 +1,113 @@
+from __future__ import annotations
+
+from typing import Any
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+from pydantic_ai.messages import (
+ ModelRequest,
+ ModelResponse,
+ RetryPromptPart,
+ SystemPromptPart,
+ ToolCallPart,
+)
+
+from codebase_rag.services.anthropic_token_counter import (
+ _to_anthropic_payload,
+ count_anthropic_context,
+)
+
+
+def _fake_post_returning(input_tokens: int) -> tuple[AsyncMock, MagicMock]:
+ fake_response = MagicMock()
+ fake_response.status_code = 200
+ fake_response.json.return_value = {"input_tokens": input_tokens}
+ fake_post = AsyncMock(return_value=fake_response)
+ return fake_post, fake_response
+
+
+@pytest.mark.asyncio
+async def test_returns_zero_when_no_messages_and_no_system_prompt() -> None:
+ with patch("httpx.AsyncClient") as mock_client:
+ result = await count_anthropic_context(
+ api_key="k", model_id="claude-opus-4-7", messages=[]
+ )
+
+ assert result == 0
+ mock_client.assert_not_called()
+
+
+@pytest.mark.asyncio
+async def test_injects_placeholder_when_only_system_prompt_present() -> None:
+ fake_post, _ = _fake_post_returning(input_tokens=42_000)
+ mock_client_instance = MagicMock()
+ mock_client_instance.__aenter__ = AsyncMock(return_value=mock_client_instance)
+ mock_client_instance.__aexit__ = AsyncMock(return_value=None)
+ mock_client_instance.post = fake_post
+
+ messages = [
+ ModelRequest(parts=[SystemPromptPart(content="GIANT SYSTEM PROMPT BODY")])
+ ]
+
+ with patch("httpx.AsyncClient", return_value=mock_client_instance):
+ result = await count_anthropic_context(
+ api_key="k", model_id="claude-opus-4-7", messages=messages
+ )
+
+ assert result == 42_000
+ payload: dict[str, Any] = fake_post.call_args.kwargs["json"]
+ assert payload["system"] == "GIANT SYSTEM PROMPT BODY"
+ assert payload["messages"]
+ assert payload["messages"][0]["role"] == "user"
+ placeholder_text = payload["messages"][0]["content"][0]["text"]
+ assert placeholder_text.strip(), "placeholder must be non-whitespace"
+
+
+def test_retry_prompt_with_tool_name_becomes_tool_result_error_block() -> None:
+ tool_call_id = "toolu_test123"
+ messages = [
+ ModelResponse(
+ parts=[
+ ToolCallPart(
+ tool_name="semantic_search",
+ args={"query": "x"},
+ tool_call_id=tool_call_id,
+ )
+ ]
+ ),
+ ModelRequest(
+ parts=[
+ RetryPromptPart(
+ content="bad args",
+ tool_name="semantic_search",
+ tool_call_id=tool_call_id,
+ )
+ ]
+ ),
+ ]
+
+ _, anthropic_messages = _to_anthropic_payload(messages)
+
+ assert len(anthropic_messages) == 2
+ assistant = anthropic_messages[0]
+ user = anthropic_messages[1]
+ assert assistant["role"] == "assistant"
+ assert assistant["content"][0]["type"] == "tool_use"
+ assert assistant["content"][0]["id"] == tool_call_id
+ assert user["role"] == "user"
+ assert user["content"][0]["type"] == "tool_result"
+ assert user["content"][0]["tool_use_id"] == tool_call_id
+ assert user["content"][0]["is_error"] is True
+
+
+def test_retry_prompt_without_tool_name_becomes_text_block() -> None:
+ messages = [
+ ModelRequest(parts=[RetryPromptPart(content="please retry")]),
+ ]
+
+ _, anthropic_messages = _to_anthropic_payload(messages)
+
+ assert len(anthropic_messages) == 1
+ assert anthropic_messages[0]["role"] == "user"
+ assert anthropic_messages[0]["content"][0]["type"] == "text"
+ assert "please retry" in anthropic_messages[0]["content"][0]["text"]
diff --git a/codebase_rag/tests/test_c_language.py b/codebase_rag/tests/test_c_language.py
new file mode 100644
index 000000000..e8253c6be
--- /dev/null
+++ b/codebase_rag/tests/test_c_language.py
@@ -0,0 +1,371 @@
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.tests.conftest import (
+ get_node_names,
+ get_nodes,
+ get_relationships,
+ run_updater,
+)
+
+
+@pytest.fixture
+def c_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "c_test_project"
+ project_path.mkdir()
+
+ (project_path / "Makefile").write_text("all:\n\tgcc -o main main.c\n")
+
+ (project_path / "main.c").write_text(
+ '#include "utils.h"\n'
+ "#include \n"
+ "\n"
+ "void greet(void) {\n"
+ ' printf("Hello\\n");\n'
+ "}\n"
+ "\n"
+ "int add(int a, int b) {\n"
+ " return a + b;\n"
+ "}\n"
+ "\n"
+ "int* get_ptr(void) {\n"
+ " static int x = 42;\n"
+ " return &x;\n"
+ "}\n"
+ "\n"
+ "int main(void) {\n"
+ " greet();\n"
+ " int result = add(1, 2);\n"
+ " int* p = get_ptr();\n"
+ " return 0;\n"
+ "}\n"
+ )
+
+ (project_path / "utils.h").write_text(
+ "#ifndef UTILS_H\n"
+ "#define UTILS_H\n"
+ "\n"
+ "int add(int a, int b);\n"
+ "void greet(void);\n"
+ "\n"
+ "#endif\n"
+ )
+
+ (project_path / "types.c").write_text(
+ "struct Point {\n"
+ " int x;\n"
+ " int y;\n"
+ "};\n"
+ "\n"
+ "union Value {\n"
+ " int i;\n"
+ " float f;\n"
+ "};\n"
+ "\n"
+ "enum Color {\n"
+ " RED,\n"
+ " GREEN,\n"
+ " BLUE\n"
+ "};\n"
+ )
+
+ return project_path
+
+
+@pytest.fixture
+def c_subdir_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "c_subdir_project"
+ project_path.mkdir()
+
+ (project_path / "CMakeLists.txt").write_text(
+ "cmake_minimum_required(VERSION 3.10)\nproject(myapp)\n"
+ )
+
+ src_dir = project_path / "src"
+ src_dir.mkdir()
+ (src_dir / "Makefile").write_text("all:\n\tgcc -o app app.c\n")
+
+ (src_dir / "app.c").write_text(
+ "void run(void) {}\n\nint main(void) {\n run();\n return 0;\n}\n"
+ )
+
+ return project_path
+
+
+class TestCFunctionNodes:
+ def test_simple_function_detected(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ func_names = get_node_names(mock_ingestor, cs.NodeLabel.FUNCTION)
+ assert any("add" in name for name in func_names)
+
+ def test_void_function_detected(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ func_names = get_node_names(mock_ingestor, cs.NodeLabel.FUNCTION)
+ assert any("greet" in name for name in func_names)
+
+ def test_pointer_return_function_detected(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ func_names = get_node_names(mock_ingestor, cs.NodeLabel.FUNCTION)
+ assert any("get_ptr" in name for name in func_names)
+
+ def test_main_function_detected(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ func_names = get_node_names(mock_ingestor, cs.NodeLabel.FUNCTION)
+ assert any("main" in name for name in func_names)
+
+ def test_function_with_parameters(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ func_nodes = get_nodes(mock_ingestor, cs.NodeLabel.FUNCTION)
+ add_nodes = [
+ n for n in func_nodes if "add" in n[0][1].get(cs.KEY_QUALIFIED_NAME, "")
+ ]
+ assert len(add_nodes) > 0
+
+
+class TestCStructNodes:
+ def test_struct_detected(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ class_names = get_node_names(mock_ingestor, cs.NodeLabel.CLASS)
+ assert any("Point" in name for name in class_names)
+
+ def test_struct_has_qualified_name(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ class_nodes = get_nodes(mock_ingestor, cs.NodeLabel.CLASS)
+ point_nodes = [
+ n for n in class_nodes if "Point" in n[0][1].get(cs.KEY_QUALIFIED_NAME, "")
+ ]
+ assert len(point_nodes) > 0
+ qn = point_nodes[0][0][1][cs.KEY_QUALIFIED_NAME]
+ assert "." in qn
+
+
+class TestCUnionNodes:
+ def test_union_detected(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ union_names = get_node_names(mock_ingestor, cs.NodeLabel.UNION)
+ class_names = get_node_names(mock_ingestor, cs.NodeLabel.CLASS)
+ all_names = union_names | class_names
+ assert any("Value" in name for name in all_names)
+
+
+class TestCEnumNodes:
+ def test_enum_detected(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ enum_names = get_node_names(mock_ingestor, cs.NodeLabel.ENUM)
+ class_names = get_node_names(mock_ingestor, cs.NodeLabel.CLASS)
+ all_names = enum_names | class_names
+ assert any("Color" in name for name in all_names)
+
+
+class TestCCallsRelationships:
+ def test_function_call_detected(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ calls = get_relationships(mock_ingestor, str(cs.RelationshipType.CALLS))
+ assert len(calls) > 0
+
+ def test_main_calls_greet(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ calls = get_relationships(mock_ingestor, str(cs.RelationshipType.CALLS))
+ call_pairs = []
+ for c in calls:
+ src = c.args[0] if c.args else c[0][0]
+ tgt = c.args[2] if len(c.args) > 2 else c[0][2]
+ if isinstance(src, tuple) and isinstance(tgt, tuple):
+ call_pairs.append((src, tgt))
+ found_greet = any(
+ "main" in str(src) and "greet" in str(tgt) for src, tgt in call_pairs
+ )
+ assert found_greet
+
+ def test_multiple_calls_from_main(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ calls = get_relationships(mock_ingestor, str(cs.RelationshipType.CALLS))
+ main_calls = [
+ c for c in calls if "main" in str(c.args[0] if c.args else c[0][0])
+ ]
+ assert len(main_calls) >= 2
+
+
+class TestCDefinesRelationships:
+ def test_module_defines_functions(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ defines = get_relationships(mock_ingestor, str(cs.RelationshipType.DEFINES))
+ assert len(defines) > 0
+
+ def test_main_module_defines_add(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ defines = get_relationships(mock_ingestor, str(cs.RelationshipType.DEFINES))
+ found = any("add" in str(d) for d in defines)
+ assert found
+
+
+class TestCImportsRelationships:
+ def test_include_creates_external_module(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ module_nodes = get_nodes(mock_ingestor, cs.NodeLabel.MODULE)
+ external_modules = [n for n in module_nodes if n[0][1].get(cs.KEY_IS_EXTERNAL)]
+ has_stdio = any("stdio" in str(n) for n in external_modules)
+ has_utils = any(
+ "utils" in n[0][1].get(cs.KEY_QUALIFIED_NAME, "") for n in module_nodes
+ )
+ assert has_stdio or has_utils
+
+ def test_include_utils_h_module_exists(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ module_nodes = get_nodes(mock_ingestor, cs.NodeLabel.MODULE)
+ module_qnames = {n[0][1].get(cs.KEY_QUALIFIED_NAME, "") for n in module_nodes}
+ assert any("utils" in qn for qn in module_qnames)
+
+
+class TestCFileAndModuleNodes:
+ def test_c_file_nodes_created(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ file_nodes = get_nodes(mock_ingestor, cs.NodeLabel.FILE)
+ file_paths = {n[0][1].get(cs.KEY_PATH, "") for n in file_nodes}
+ assert any("main.c" in p for p in file_paths)
+ assert any("types.c" in p for p in file_paths)
+
+ def test_c_module_nodes_created(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ module_nodes = get_nodes(mock_ingestor, cs.NodeLabel.MODULE)
+ module_names = {n[0][1].get(cs.KEY_QUALIFIED_NAME, "") for n in module_nodes}
+ assert any("main" in name for name in module_names)
+
+ def test_header_file_node_created(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ file_nodes = get_nodes(mock_ingestor, cs.NodeLabel.FILE)
+ file_paths = {n[0][1].get(cs.KEY_PATH, "") for n in file_nodes}
+ assert any("utils.h" in p for p in file_paths)
+
+
+class TestCQualifiedNames:
+ def test_function_qualified_name_has_project(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ func_names = get_node_names(mock_ingestor, cs.NodeLabel.FUNCTION)
+ for name in func_names:
+ assert "." in name, f"Qualified name should contain '.': {name}"
+
+ def test_function_qualified_name_format(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ func_names = get_node_names(mock_ingestor, cs.NodeLabel.FUNCTION)
+ add_names = [n for n in func_names if "add" in n]
+ assert len(add_names) > 0
+ parts = add_names[0].split(".")
+ assert len(parts) >= 2
+
+
+class TestCPackageDetection:
+ def test_makefile_creates_package(
+ self,
+ c_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_project, mock_ingestor, skip_if_missing="c")
+ package_nodes = get_nodes(mock_ingestor, cs.NodeLabel.PACKAGE)
+ assert len(package_nodes) > 0
+
+ def test_cmakelists_creates_package(
+ self,
+ c_subdir_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_subdir_project, mock_ingestor, skip_if_missing="c")
+ package_nodes = get_nodes(mock_ingestor, cs.NodeLabel.PACKAGE)
+ assert len(package_nodes) > 0
+
+ def test_subdirectory_with_makefile_is_package(
+ self,
+ c_subdir_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ run_updater(c_subdir_project, mock_ingestor, skip_if_missing="c")
+ package_nodes = get_nodes(mock_ingestor, cs.NodeLabel.PACKAGE)
+ package_qnames = {n[0][1].get(cs.KEY_QUALIFIED_NAME, "") for n in package_nodes}
+ assert any("src" in qn for qn in package_qnames)
diff --git a/codebase_rag/tests/test_call_processor.py b/codebase_rag/tests/test_call_processor.py
index a6ae5cc34..4cab76cfd 100644
--- a/codebase_rag/tests/test_call_processor.py
+++ b/codebase_rag/tests/test_call_processor.py
@@ -1153,8 +1153,10 @@ def test_logs_error_on_processing_failure(
tree = parser.parse(b"def foo(): pass")
root_node = tree.root_node
+ from codebase_rag.parsers.call_processor import CallProcessor
+
with patch.object(
- call_processor,
+ CallProcessor,
"_process_calls_in_functions",
side_effect=RuntimeError("Simulated failure"),
):
@@ -1166,9 +1168,9 @@ def test_logs_error_on_processing_failure(
queries,
)
mock_logger.error.assert_called_once()
- error_call_args = mock_logger.error.call_args[0][0]
- assert "test_module.py" in error_call_args
- assert "Simulated failure" in error_call_args
+ error_call_args = mock_logger.error.call_args
+ assert "test_module.py" in str(error_call_args)
+ assert "Simulated failure" in str(error_call_args)
def test_continues_after_error_in_single_file(
self,
@@ -1195,8 +1197,10 @@ def test_continues_after_error_in_single_file(
tree = parser.parse(b"def foo(): pass")
root_node = tree.root_node
+ from codebase_rag.parsers.call_processor import CallProcessor
+
with patch.object(
- call_processor,
+ CallProcessor,
"_process_calls_in_functions",
side_effect=ValueError("Test exception"),
):
@@ -1206,3 +1210,452 @@ def test_continues_after_error_in_single_file(
cs.SupportedLanguage.PYTHON,
queries,
)
+
+
+class TestCallProcessorSlots:
+ def test_has_slots(self) -> None:
+ from codebase_rag.parsers.call_processor import CallProcessor
+
+ assert hasattr(CallProcessor, "__slots__")
+
+ def test_no_instance_dict(self, call_processor: CallProcessor) -> None:
+ assert not hasattr(call_processor, "__dict__")
+
+ def test_rejects_arbitrary_attribute(self, call_processor: CallProcessor) -> None:
+ with pytest.raises(AttributeError):
+ call_processor.nonexistent_attr = 42
+
+ def test_slot_attributes_accessible(self, call_processor: CallProcessor) -> None:
+ assert hasattr(call_processor, "ingestor")
+ assert hasattr(call_processor, "repo_path")
+ assert hasattr(call_processor, "project_name")
+ assert hasattr(call_processor, "_resolver")
+
+
+class TestCollectAllCallNodes:
+ def test_returns_empty_when_no_calls_query(
+ self,
+ call_processor: CallProcessor,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ code = "x = 1"
+ root = parse_code(code, cs.SupportedLanguage.PYTHON, parsers)
+
+ empty_queries: dict = {cs.SupportedLanguage.PYTHON: {cs.QUERY_CALLS: None}}
+ call_nodes, call_starts = call_processor._collect_all_call_nodes(
+ root, cs.SupportedLanguage.PYTHON, empty_queries
+ )
+ assert call_nodes == []
+ assert call_starts == []
+
+ def test_returns_call_nodes_for_code_with_calls(
+ self,
+ call_processor: CallProcessor,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ code = "foo()\nbar()"
+ root = parse_code(code, cs.SupportedLanguage.PYTHON, parsers)
+ call_nodes, call_starts = call_processor._collect_all_call_nodes(
+ root, cs.SupportedLanguage.PYTHON, queries
+ )
+ assert len(call_nodes) >= 2
+ assert len(call_starts) == len(call_nodes)
+ assert all(isinstance(s, int) for s in call_starts)
+
+
+class TestFilterCallsInNode:
+ def test_filters_calls_within_container(
+ self,
+ call_processor: CallProcessor,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ code = """
+def outer():
+ foo()
+
+def other():
+ bar()
+"""
+ root = parse_code(code, cs.SupportedLanguage.PYTHON, parsers)
+ all_call_nodes, call_starts = call_processor._collect_all_call_nodes(
+ root, cs.SupportedLanguage.PYTHON, queries
+ )
+ assert len(all_call_nodes) >= 2
+
+ outer_func = find_first_node_of_type(root, "function_definition")
+ assert outer_func is not None
+
+ filtered = call_processor._filter_calls_in_node(
+ all_call_nodes, call_starts, outer_func
+ )
+ assert len(filtered) == 1
+
+
+class TestProcessCallsInFileWithoutCache:
+ def test_process_calls_without_func_class_captures_cache(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ test_file = temp_repo / "test_module.py"
+ test_file.write_text(encoding="utf-8", data="def foo(): bar()")
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ cp = updater.factory.call_processor
+
+ parser = parsers[cs.SupportedLanguage.PYTHON]
+ tree = parser.parse(b"def foo(): bar()")
+ root_node = tree.root_node
+
+ cp.process_calls_in_file(
+ test_file,
+ root_node,
+ cs.SupportedLanguage.PYTHON,
+ queries,
+ func_class_captures_cache=None,
+ )
+
+ def test_process_calls_with_empty_combined_captures(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ test_file = temp_repo / "test_module.py"
+ test_file.write_text(encoding="utf-8", data="x = 1")
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ cp = updater.factory.call_processor
+
+ parser = parsers[cs.SupportedLanguage.PYTHON]
+ tree = parser.parse(b"x = 1")
+ root_node = tree.root_node
+
+ from codebase_rag.parser_loader import COMBINED_FUNC_CLASS_QUERIES
+
+ original = COMBINED_FUNC_CLASS_QUERIES.get(cs.SupportedLanguage.PYTHON)
+ try:
+ COMBINED_FUNC_CLASS_QUERIES[cs.SupportedLanguage.PYTHON] = None
+ cp.process_calls_in_file(
+ test_file,
+ root_node,
+ cs.SupportedLanguage.PYTHON,
+ queries,
+ func_class_captures_cache=None,
+ )
+ finally:
+ if original is not None:
+ COMBINED_FUNC_CLASS_QUERIES[cs.SupportedLanguage.PYTHON] = original
+
+
+class TestProcessCallsInFunctionsWithoutCombined:
+ def test_without_combined_captures(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ cp = updater.factory.call_processor
+
+ code = "def foo(): bar()"
+ parser = parsers[cs.SupportedLanguage.PYTHON]
+ tree = parser.parse(code.encode(cs.ENCODING_UTF8))
+ root_node = tree.root_node
+
+ cp._process_calls_in_functions(
+ root_node,
+ "proj.module",
+ cs.SupportedLanguage.PYTHON,
+ queries,
+ combined_captures=None,
+ )
+
+ def test_without_combined_captures_no_functions(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ cp = updater.factory.call_processor
+
+ code = "x = 1"
+ parser = parsers[cs.SupportedLanguage.PYTHON]
+ tree = parser.parse(code.encode(cs.ENCODING_UTF8))
+ root_node = tree.root_node
+
+ cp._process_calls_in_functions(
+ root_node,
+ "proj.module",
+ cs.SupportedLanguage.PYTHON,
+ queries,
+ combined_captures=None,
+ )
+
+
+class TestProcessCallsInClassesWithoutCombined:
+ def test_without_combined_captures(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ cp = updater.factory.call_processor
+
+ code = """
+class MyClass:
+ def method(self):
+ foo()
+"""
+ parser = parsers[cs.SupportedLanguage.PYTHON]
+ tree = parser.parse(code.encode(cs.ENCODING_UTF8))
+ root_node = tree.root_node
+
+ cp._process_calls_in_classes(
+ root_node,
+ "proj.module",
+ cs.SupportedLanguage.PYTHON,
+ queries,
+ combined_captures=None,
+ )
+
+
+class TestProcessMethodsInClassWithoutSortedFuncNodes:
+ def test_without_sorted_func_nodes(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ cp = updater.factory.call_processor
+
+ code = """
+class MyClass:
+ def method(self):
+ foo()
+"""
+ parser = parsers[cs.SupportedLanguage.PYTHON]
+ tree = parser.parse(code.encode(cs.ENCODING_UTF8))
+ root_node = tree.root_node
+
+ class_node = find_first_node_of_type(root_node, "class_definition")
+ assert class_node is not None
+ body_node = class_node.child_by_field_name("body")
+ assert body_node is not None
+
+ cp._process_methods_in_class(
+ body_node,
+ "proj.module.MyClass",
+ "proj.module",
+ cs.SupportedLanguage.PYTHON,
+ queries,
+ sorted_func_nodes=None,
+ func_node_starts=None,
+ )
+
+
+class TestIngestFunctionCallsWithoutCallNodes:
+ def test_without_call_nodes(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ cp = updater.factory.call_processor
+
+ code = "def foo(): bar()"
+ parser = parsers[cs.SupportedLanguage.PYTHON]
+ tree = parser.parse(code.encode(cs.ENCODING_UTF8))
+ root_node = tree.root_node
+
+ cp._ingest_function_calls(
+ root_node,
+ "proj.module.foo",
+ cs.NodeLabel.FUNCTION,
+ "proj.module",
+ cs.SupportedLanguage.PYTHON,
+ queries,
+ call_nodes=None,
+ )
+
+ def test_without_call_nodes_and_no_query(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ cp = updater.factory.call_processor
+
+ code = "x = 1"
+ parser = parsers[cs.SupportedLanguage.PYTHON]
+ tree = parser.parse(code.encode(cs.ENCODING_UTF8))
+ root_node = tree.root_node
+
+ empty_queries: dict = {
+ cs.SupportedLanguage.PYTHON: {cs.QUERY_CALLS: None, cs.QUERY_CONFIG: queries[cs.SupportedLanguage.PYTHON][cs.QUERY_CONFIG]}
+ }
+ cp._ingest_function_calls(
+ root_node,
+ "proj.module.foo",
+ cs.NodeLabel.FUNCTION,
+ "proj.module",
+ cs.SupportedLanguage.PYTHON,
+ empty_queries,
+ call_nodes=None,
+ )
+
+
+class TestCombinedQueryCompilationExceptionPaths:
+ def test_combined_func_class_query_exception_sets_none(
+ self,
+ parsers_and_queries: tuple,
+ ) -> None:
+ from tree_sitter import Query as RealQuery
+
+ from codebase_rag.parser_loader import (
+ COMBINED_FUNC_CLASS_IMPORT_QUERIES,
+ COMBINED_FUNC_CLASS_QUERIES,
+ _create_language_queries,
+ )
+
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ lang_queries = queries[cs.SupportedLanguage.PYTHON]
+ language_obj = lang_queries[cs.QUERY_LANGUAGE]
+ parser = parsers[cs.SupportedLanguage.PYTHON]
+ lang_config = lang_queries[cs.QUERY_CONFIG]
+
+ call_count = 0
+
+ def patched_query(language, pattern):
+ nonlocal call_count
+ call_count += 1
+ if call_count <= 2:
+ raise RuntimeError("simulated combined query failure")
+ return RealQuery(language, pattern)
+
+ original_fc = COMBINED_FUNC_CLASS_QUERIES.get(cs.SupportedLanguage.PYTHON)
+ original_fci = COMBINED_FUNC_CLASS_IMPORT_QUERIES.get(cs.SupportedLanguage.PYTHON)
+ try:
+ with patch("codebase_rag.parser_loader.Query", side_effect=patched_query):
+ _create_language_queries(
+ language_obj, parser, lang_config, cs.SupportedLanguage.PYTHON
+ )
+ assert COMBINED_FUNC_CLASS_QUERIES[cs.SupportedLanguage.PYTHON] is None
+ assert COMBINED_FUNC_CLASS_IMPORT_QUERIES[cs.SupportedLanguage.PYTHON] is None
+ finally:
+ if original_fc is not None:
+ COMBINED_FUNC_CLASS_QUERIES[cs.SupportedLanguage.PYTHON] = original_fc
+ if original_fci is not None:
+ COMBINED_FUNC_CLASS_IMPORT_QUERIES[cs.SupportedLanguage.PYTHON] = original_fci
+
+
+class TestGetRustImplClassName:
+ def test_rust_impl_fallback_to_children(
+ self,
+ call_processor: CallProcessor,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, _ = parsers_and_queries
+ if cs.SupportedLanguage.RUST not in parsers:
+ pytest.skip("Rust parser not available")
+
+ code = "impl MyStruct { fn foo(&self) {} }"
+ root = parse_code(code, cs.SupportedLanguage.RUST, parsers)
+ impl_node = find_first_node_of_type(root, "impl_item")
+ assert impl_node is not None
+
+ result = call_processor._get_rust_impl_class_name(impl_node)
+ assert result is not None
diff --git a/codebase_rag/tests/test_call_processor_integration.py b/codebase_rag/tests/test_call_processor_integration.py
index e388b96c4..b3b326ba7 100644
--- a/codebase_rag/tests/test_call_processor_integration.py
+++ b/codebase_rag/tests/test_call_processor_integration.py
@@ -793,7 +793,11 @@ def with_value(self, value):
def build(self):
return {}
+def helper():
+ pass
+
def main():
+ helper()
result = Builder().with_name("test").with_value(42).build()
return result
""",
@@ -814,6 +818,10 @@ def main():
]
assert len(calls) >= 1
+ # (H) Builder() is a class instantiation, not a function call
+ class_targets = [c for c in calls if c.args[2][0] == cs.NodeLabel.CLASS]
+ assert len(class_targets) == 0
+
def test_handles_init_py_module_qn(
self,
temp_repo: Path,
@@ -853,3 +861,90 @@ def package_func():
caller_qns = [c.args[0][2] for c in calls]
package_callers = [qn for qn in caller_qns if "mypackage" in qn]
assert len(package_callers) >= 1
+
+
+class TestModuleCallsClassFiltered:
+ def test_module_does_not_call_class_python(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ test_file = temp_repo / "test_module.py"
+ test_file.write_text(
+ encoding="utf-8",
+ data="""
+class MyClass:
+ def method(self):
+ pass
+
+def helper():
+ pass
+
+helper()
+""",
+ )
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ calls = [
+ c
+ for c in mock_ingestor.ensure_relationship_batch.call_args_list
+ if c.args[1] == cs.RelationshipType.CALLS
+ ]
+
+ class_targets = [c for c in calls if c.args[2][0] == cs.NodeLabel.CLASS]
+ assert class_targets == []
+
+ helper_calls = [c for c in calls if "helper" in c.args[2][2]]
+ assert len(helper_calls) >= 1
+
+ def test_function_does_not_call_class_python(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple,
+ ) -> None:
+ parsers, queries = parsers_and_queries
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ test_file = temp_repo / "test_module.py"
+ test_file.write_text(
+ encoding="utf-8",
+ data="""
+class MyClass:
+ pass
+
+def factory():
+ obj = MyClass()
+ return obj
+""",
+ )
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ calls = [
+ c
+ for c in mock_ingestor.ensure_relationship_batch.call_args_list
+ if c.args[1] == cs.RelationshipType.CALLS
+ ]
+
+ class_targets = [c for c in calls if c.args[2][0] == cs.NodeLabel.CLASS]
+ assert class_targets == []
diff --git a/codebase_rag/tests/test_call_resolver.py b/codebase_rag/tests/test_call_resolver.py
index da4108f95..84d8151c5 100644
--- a/codebase_rag/tests/test_call_resolver.py
+++ b/codebase_rag/tests/test_call_resolver.py
@@ -24,6 +24,9 @@ class MockFunctionRegistry:
def __init__(self) -> None:
self._data: dict[QualifiedName, NodeType] = {}
self._suffix_index: dict[str, list[QualifiedName]] = defaultdict(list)
+ self._properties: set[QualifiedName] = set()
+ self._property_names: set[str] = set()
+ self._abstracts: set[QualifiedName] = set()
def __contains__(self, qn: QualifiedName) -> bool:
return qn in self._data
@@ -56,6 +59,28 @@ def find_with_prefix(self, prefix: str) -> list[tuple[QualifiedName, NodeType]]:
def find_ending_with(self, suffix: str) -> list[QualifiedName]:
return self._suffix_index.get(suffix, [])
+ def register_unique_qn(self, natural_qn: QualifiedName, start_line: int) -> str:
+ return natural_qn
+
+ def variants(self, qn: QualifiedName) -> list[QualifiedName]:
+ return [qn]
+
+ def mark_property(self, qn: QualifiedName) -> None:
+ self._properties.add(qn)
+ self._property_names.add(qn.rsplit(cs.SEPARATOR_DOT, 1)[-1])
+
+ def is_property(self, qn: QualifiedName) -> bool:
+ return qn in self._properties
+
+ def property_names(self) -> set[str]:
+ return self._property_names
+
+ def mark_abstract(self, qn: QualifiedName) -> None:
+ self._abstracts.add(qn)
+
+ def is_abstract(self, qn: QualifiedName) -> bool:
+ return qn in self._abstracts
+
@pytest.fixture
def mock_function_registry() -> MockFunctionRegistry:
@@ -1024,3 +1049,356 @@ def test_falls_back_to_trie(self, call_resolver: CallResolver) -> None:
def test_returns_none_for_unknown(self, call_resolver: CallResolver) -> None:
result = call_resolver.resolve_function_call("unknown_func", "proj.module")
assert result is None
+
+
+class TestDequeBfs:
+ def test_bfs_order_prefers_closer_parent(self, call_resolver: CallResolver) -> None:
+ call_resolver.function_registry["proj.base.ParentA.method"] = NodeType.METHOD
+ call_resolver.function_registry["proj.base.ParentB.method"] = NodeType.METHOD
+ call_resolver.class_inheritance["proj.module.Child"] = [
+ "proj.base.ParentA",
+ "proj.base.ParentB",
+ ]
+
+ result = call_resolver._resolve_inherited_method("proj.module.Child", "method")
+ assert result is not None
+ assert result[1] == "proj.base.ParentA.method"
+
+ def test_bfs_finds_deep_ancestor_method(self, call_resolver: CallResolver) -> None:
+ call_resolver.function_registry["proj.base.Root.deep_method"] = NodeType.METHOD
+ call_resolver.class_inheritance["proj.module.Child"] = ["proj.mid.Middle"]
+ call_resolver.class_inheritance["proj.mid.Middle"] = ["proj.base.Root"]
+
+ result = call_resolver._resolve_inherited_method(
+ "proj.module.Child", "deep_method"
+ )
+ assert result is not None
+ assert result[1] == "proj.base.Root.deep_method"
+
+ def test_bfs_no_infinite_loop_on_cycle(self, call_resolver: CallResolver) -> None:
+ call_resolver.class_inheritance["proj.A"] = ["proj.B"]
+ call_resolver.class_inheritance["proj.B"] = ["proj.A"]
+
+ result = call_resolver._resolve_inherited_method("proj.A", "missing")
+ assert result is None
+
+
+class TestSeparatorPattern:
+ def test_splits_on_dot(self) -> None:
+ from codebase_rag.parsers.call_resolver import _SEPARATOR_PATTERN
+
+ assert _SEPARATOR_PATTERN.split("a.b.c") == ["a", "b", "c"]
+
+ def test_splits_on_colon(self) -> None:
+ from codebase_rag.parsers.call_resolver import _SEPARATOR_PATTERN
+
+ assert _SEPARATOR_PATTERN.split("module:func") == ["module", "func"]
+
+ def test_splits_on_double_colon(self) -> None:
+ from codebase_rag.parsers.call_resolver import _SEPARATOR_PATTERN
+
+ assert _SEPARATOR_PATTERN.split("crate::module::func") == [
+ "crate",
+ "",
+ "module",
+ "",
+ "func",
+ ]
+
+ def test_no_separator_returns_single_element(self) -> None:
+ from codebase_rag.parsers.call_resolver import _SEPARATOR_PATTERN
+
+ assert _SEPARATOR_PATTERN.split("simple") == ["simple"]
+
+ def test_last_element_matches_function_name(self) -> None:
+ from codebase_rag.parsers.call_resolver import _SEPARATOR_PATTERN
+
+ assert _SEPARATOR_PATTERN.split("a.b.func")[-1] == "func"
+ assert _SEPARATOR_PATTERN.split("module:method")[-1] == "method"
+
+
+class TestChainedMethodPattern:
+ def test_matches_final_method(self) -> None:
+ from codebase_rag.parsers.call_resolver import _CHAINED_METHOD_PATTERN
+
+ match = _CHAINED_METHOD_PATTERN.search("obj.method().next")
+ assert match is not None
+ assert match[1] == "next"
+
+ def test_no_match_on_parenthesized_suffix(self) -> None:
+ from codebase_rag.parsers.call_resolver import _CHAINED_METHOD_PATTERN
+
+ match = _CHAINED_METHOD_PATTERN.search("obj.method()")
+ assert match is None
+
+ def test_matches_deeply_chained(self) -> None:
+ from codebase_rag.parsers.call_resolver import _CHAINED_METHOD_PATTERN
+
+ match = _CHAINED_METHOD_PATTERN.search("a.b().c().final_method")
+ assert match is not None
+ assert match[1] == "final_method"
+
+
+class TestDeterministicResolution:
+ def test_trie_tiebreak_by_qualified_name(self, call_resolver: CallResolver) -> None:
+ # (H) Register multiple functions with the same simple name in different modules
+ # (H) at equal import distance from the caller
+ call_resolver.function_registry["proj.alpha.utils.helper"] = NodeType.FUNCTION
+ call_resolver.function_registry["proj.beta.utils.helper"] = NodeType.FUNCTION
+ call_resolver.function_registry["proj.gamma.utils.helper"] = NodeType.FUNCTION
+
+ results = []
+ for _ in range(20):
+ result = call_resolver._try_resolve_via_trie("helper", "proj.delta.module")
+ assert result is not None
+ results.append(result[1])
+
+ # (H) All 20 runs must resolve to the same candidate (lexicographically first)
+ assert all(r == results[0] for r in results)
+ assert results[0] == "proj.alpha.utils.helper"
+
+ def test_trie_tiebreak_picks_lexicographic_first(
+ self, call_resolver: CallResolver
+ ) -> None:
+ # (H) Deliberately insert in reverse lexicographic order
+ call_resolver.function_registry["proj.zoo.compute"] = NodeType.FUNCTION
+ call_resolver.function_registry["proj.mid.compute"] = NodeType.FUNCTION
+ call_resolver.function_registry["proj.aaa.compute"] = NodeType.FUNCTION
+
+ result = call_resolver._try_resolve_via_trie("compute", "other.module")
+ assert result is not None
+ assert result[1] == "proj.aaa.compute"
+
+ def test_trie_tiebreak_distance_still_wins(
+ self, call_resolver: CallResolver
+ ) -> None:
+ # (H) Closer module should win even if lexicographically later
+ call_resolver.function_registry["proj.far.away.process"] = NodeType.FUNCTION
+ call_resolver.function_registry["proj.module.process"] = NodeType.FUNCTION
+
+ result = call_resolver._try_resolve_via_trie("process", "proj.module.caller")
+ assert result is not None
+ # (H) proj.module.process is closer to proj.module.caller
+ assert result[1] == "proj.module.process"
+
+ def test_trie_many_candidates_deterministic(
+ self, call_resolver: CallResolver
+ ) -> None:
+ # (H) Register 10 equidistant candidates
+ names = [
+ "proj.m09.run",
+ "proj.m05.run",
+ "proj.m01.run",
+ "proj.m07.run",
+ "proj.m03.run",
+ "proj.m08.run",
+ "proj.m02.run",
+ "proj.m06.run",
+ "proj.m04.run",
+ "proj.m10.run",
+ ]
+ for name in names:
+ call_resolver.function_registry[name] = NodeType.FUNCTION
+
+ result = call_resolver._try_resolve_via_trie("run", "other.caller")
+ assert result is not None
+ assert result[1] == "proj.m01.run"
+
+ def test_resolve_function_call_deterministic_across_runs(
+ self, call_resolver: CallResolver
+ ) -> None:
+ call_resolver.function_registry["pkg.svc_a.validate"] = NodeType.FUNCTION
+ call_resolver.function_registry["pkg.svc_b.validate"] = NodeType.FUNCTION
+ call_resolver.function_registry["pkg.svc_c.validate"] = NodeType.FUNCTION
+
+ results = set()
+ for _ in range(10):
+ result = call_resolver.resolve_function_call(
+ "validate", "pkg.other.module", {}, None
+ )
+ assert result is not None
+ results.add(result[1])
+
+ # (H) Must resolve to exactly one candidate across all runs
+ assert len(results) == 1
+
+
+class TestDeterministicFileOrder:
+ def test_eligible_files_are_sorted(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+
+ # (H) Create files in non-alphabetical order
+ for name in ["zebra.py", "alpha.py", "middle.py", "beta.py"]:
+ (temp_repo / name).write_text(f"def func_{name[0]}(): pass\n")
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ eligible = updater._collect_eligible_files()
+ paths_str = [str(f) for f in eligible]
+
+ assert paths_str == sorted(paths_str)
+
+ def test_graph_output_deterministic_across_runs(self, temp_repo: Path) -> None:
+ parsers, queries = load_parsers()
+
+ (temp_repo / "mod_a.py").write_text(
+ "def shared(): pass\ndef call_a(): shared()\n"
+ )
+ (temp_repo / "mod_b.py").write_text(
+ "def shared(): pass\ndef call_b(): shared()\n"
+ )
+
+ results = []
+ for _ in range(5):
+ ingestor = MagicMock()
+ updater = GraphUpdater(
+ ingestor=ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run(force=True)
+
+ calls = [
+ (c.args[0][2], c.args[1], c.args[2][2])
+ for c in ingestor.ensure_relationship_batch.call_args_list
+ if c.args[1] == cs.RelationshipType.CALLS
+ ]
+ calls.sort()
+ results.append(calls)
+
+ # (H) All 5 runs must produce identical call graphs
+ assert len(results[0]) > 0
+ for i in range(1, len(results)):
+ assert results[i] == results[0]
+
+ def _run_determinism_check(self, temp_repo: Path, runs: int = 5) -> None:
+ parsers, queries = load_parsers()
+ results = []
+ for _ in range(runs):
+ ingestor = MagicMock()
+ updater = GraphUpdater(
+ ingestor=ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run(force=True)
+
+ calls = [
+ (c.args[0][2], c.args[2][2])
+ for c in ingestor.ensure_relationship_batch.call_args_list
+ if c.args[1] == cs.RelationshipType.CALLS
+ ]
+ calls.sort()
+ results.append(calls)
+
+ assert len(results[0]) > 0
+ for i in range(1, len(results)):
+ assert results[i] == results[0]
+
+ def test_javascript_deterministic(self, temp_repo: Path) -> None:
+ parsers, _ = load_parsers()
+ if cs.SupportedLanguage.JS not in parsers:
+ pytest.skip("JavaScript parser not available")
+
+ (temp_repo / "utils.js").write_text(
+ "function helper() {}\nfunction worker() { helper(); }\n"
+ )
+ (temp_repo / "main.js").write_text(
+ "function helper() {}\nfunction entry() { helper(); }\n"
+ )
+ self._run_determinism_check(temp_repo)
+
+ def test_typescript_deterministic(self, temp_repo: Path) -> None:
+ parsers, _ = load_parsers()
+ if cs.SupportedLanguage.TS not in parsers:
+ pytest.skip("TypeScript parser not available")
+
+ (temp_repo / "service.ts").write_text(
+ "function validate(x: string): boolean { return true; }\n"
+ "function process() { validate('test'); }\n"
+ )
+ (temp_repo / "handler.ts").write_text(
+ "function validate(x: string): boolean { return false; }\n"
+ "function handle() { validate('input'); }\n"
+ )
+ self._run_determinism_check(temp_repo)
+
+ def test_rust_deterministic(self, temp_repo: Path) -> None:
+ parsers, _ = load_parsers()
+ if cs.SupportedLanguage.RUST not in parsers:
+ pytest.skip("Rust parser not available")
+
+ (temp_repo / "utils.rs").write_text(
+ "fn compute() -> i32 { 42 }\nfn run() { compute(); }\n"
+ )
+ (temp_repo / "main.rs").write_text(
+ "fn compute() -> i32 { 0 }\nfn start() { compute(); }\n"
+ )
+ self._run_determinism_check(temp_repo)
+
+ def test_java_deterministic(self, temp_repo: Path) -> None:
+ parsers, _ = load_parsers()
+ if cs.SupportedLanguage.JAVA not in parsers:
+ pytest.skip("Java parser not available")
+
+ (temp_repo / "Utils.java").write_text(
+ "public class Utils {\n"
+ " public static void process() {}\n"
+ " public static void run() { process(); }\n"
+ "}\n"
+ )
+ (temp_repo / "Helper.java").write_text(
+ "public class Helper {\n"
+ " public static void process() {}\n"
+ " public static void execute() { process(); }\n"
+ "}\n"
+ )
+ self._run_determinism_check(temp_repo)
+
+ def test_cpp_deterministic(self, temp_repo: Path) -> None:
+ parsers, _ = load_parsers()
+ if cs.SupportedLanguage.CPP not in parsers:
+ pytest.skip("C++ parser not available")
+
+ (temp_repo / "math.cpp").write_text(
+ "int calculate() { return 1; }\nint run() { return calculate(); }\n"
+ )
+ (temp_repo / "logic.cpp").write_text(
+ "int calculate() { return 2; }\nint start() { return calculate(); }\n"
+ )
+ self._run_determinism_check(temp_repo)
+
+ def test_go_deterministic(self, temp_repo: Path) -> None:
+ parsers, _ = load_parsers()
+ if cs.SupportedLanguage.GO not in parsers:
+ pytest.skip("Go parser not available")
+
+ (temp_repo / "util.go").write_text(
+ "package main\nfunc helper() {}\nfunc doWork() { helper() }\n"
+ )
+ (temp_repo / "main.go").write_text(
+ "package main\nfunc helper() {}\nfunc run() { helper() }\n"
+ )
+ self._run_determinism_check(temp_repo)
+
+ def test_lua_deterministic(self, temp_repo: Path) -> None:
+ parsers, _ = load_parsers()
+ if cs.SupportedLanguage.LUA not in parsers:
+ pytest.skip("Lua parser not available")
+
+ (temp_repo / "utils.lua").write_text(
+ "local function process() end\nlocal function run() process() end\n"
+ )
+ (temp_repo / "main.lua").write_text(
+ "local function process() end\nlocal function start() process() end\n"
+ )
+ self._run_determinism_check(temp_repo)
diff --git a/codebase_rag/tests/test_callable_field_calls.py b/codebase_rag/tests/test_callable_field_calls.py
new file mode 100644
index 000000000..96316ab8f
--- /dev/null
+++ b/codebase_rag/tests/test_callable_field_calls.py
@@ -0,0 +1,132 @@
+# (H) L3 finding from the evals/ harness: fqn_config.get_name(node) invokes a
+# (H) function stored in a NamedTuple Callable field (FQNSpec), where fqn_config
+# (H) comes from LANGUAGE_FQN_SPECS.get(language). Every function bound to that
+# (H) field at a construction site is a possible callee, so resolving to all of
+# (H) them is a sound call graph and captures the traced (Python) edge.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+# (H) fetch_name is a callable field of exactly one NamedTuple, mirroring how
+# (H) get_name is unique to FQNSpec, so it resolves without a receiver type.
+MODULE_SRC = """from typing import Callable, NamedTuple
+
+
+def py_name() -> str:
+ return "py"
+
+
+def js_name() -> str:
+ return "js"
+
+
+class Spec(NamedTuple):
+ fetch_name: Callable[[], str]
+
+
+PY_SPEC = Spec(fetch_name=py_name)
+JS_SPEC = Spec(fetch_name=js_name)
+
+SPECS = {"py": PY_SPEC, "js": JS_SPEC}
+
+
+def use(lang: str) -> str:
+ spec = SPECS.get(lang)
+ return spec.fetch_name()
+"""
+
+# (H) Two classes share the field name, so with no receiver type the targets are
+# (H) ambiguous and must NOT be emitted (precision guard).
+AMBIGUOUS_SRC = """from typing import Callable, NamedTuple
+
+
+def a_name() -> str:
+ return "a"
+
+
+def b_name() -> str:
+ return "b"
+
+
+class SpecA(NamedTuple):
+ shared_cb: Callable[[], str]
+
+
+class SpecB(NamedTuple):
+ shared_cb: Callable[[], str]
+
+
+A = SpecA(shared_cb=a_name)
+B = SpecB(shared_cb=b_name)
+
+
+def run(flag: bool):
+ chosen = A if flag else B
+ return chosen.shared_cb()
+"""
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path, src: str) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "m.py").write_text(src)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestCallableFieldCalls:
+ def test_resolves_to_first_bound_function(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path, MODULE_SRC)
+ assert ("proj.m.use", "proj.m.py_name") in calls, calls
+
+ def test_resolves_to_all_bound_functions(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path, MODULE_SRC)
+ assert ("proj.m.use", "proj.m.js_name") in calls, calls
+
+ def test_ambiguous_field_name_not_resolved(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path, AMBIGUOUS_SRC)
+ assert ("proj.m.run", "proj.m.a_name") not in calls, calls
+ assert ("proj.m.run", "proj.m.b_name") not in calls, calls
diff --git a/codebase_rag/tests/test_cancel_orphaned_tool_calls.py b/codebase_rag/tests/test_cancel_orphaned_tool_calls.py
new file mode 100644
index 000000000..acff644a7
--- /dev/null
+++ b/codebase_rag/tests/test_cancel_orphaned_tool_calls.py
@@ -0,0 +1,91 @@
+from __future__ import annotations
+
+from pydantic_ai.messages import (
+ ModelMessage,
+ ModelRequest,
+ ModelResponse,
+ SystemPromptPart,
+ TextPart,
+ ToolCallPart,
+ ToolReturnPart,
+ UserPromptPart,
+)
+
+from codebase_rag import constants as cs
+from codebase_rag.main import _cancel_orphaned_tool_calls
+
+
+def test_noop_when_history_empty() -> None:
+ history: list[ModelMessage] = []
+ _cancel_orphaned_tool_calls(history)
+ assert history == []
+
+
+def test_noop_when_last_message_is_request() -> None:
+ history: list[ModelMessage] = [ModelRequest(parts=[UserPromptPart(content="hi")])]
+ _cancel_orphaned_tool_calls(history)
+ assert len(history) == 1
+
+
+def test_noop_when_response_has_no_tool_calls() -> None:
+ history: list[ModelMessage] = [
+ ModelRequest(parts=[SystemPromptPart(content="sys")]),
+ ModelResponse(parts=[TextPart(content="hello")]),
+ ]
+ _cancel_orphaned_tool_calls(history)
+ assert len(history) == 2
+
+
+def test_appends_synthetic_return_for_each_orphan_tool_call() -> None:
+ history: list[ModelMessage] = [
+ ModelRequest(parts=[UserPromptPart(content="run stuff")]),
+ ModelResponse(
+ parts=[
+ ToolCallPart(
+ tool_name="shell_command",
+ args={"command": "ls"},
+ tool_call_id="call_1",
+ ),
+ ToolCallPart(
+ tool_name="read_file",
+ args={"path": "/tmp/x"},
+ tool_call_id="call_2",
+ ),
+ ]
+ ),
+ ]
+
+ _cancel_orphaned_tool_calls(history)
+
+ assert len(history) == 3
+ repaired = history[-1]
+ assert isinstance(repaired, ModelRequest)
+ returns = [p for p in repaired.parts if isinstance(p, ToolReturnPart)]
+ assert len(returns) == 2
+ assert {r.tool_call_id for r in returns} == {"call_1", "call_2"}
+ for r in returns:
+ assert r.content == cs.MSG_TOOL_CALL_CANCELLED
+
+
+def test_ignores_non_tool_call_parts_in_response() -> None:
+ history: list[ModelMessage] = [
+ ModelResponse(
+ parts=[
+ TextPart(content="some text"),
+ ToolCallPart(
+ tool_name="shell_command",
+ args={"command": "ls"},
+ tool_call_id="call_1",
+ ),
+ ]
+ ),
+ ]
+
+ _cancel_orphaned_tool_calls(history)
+
+ assert len(history) == 2
+ repaired = history[-1]
+ assert isinstance(repaired, ModelRequest)
+ returns = [p for p in repaired.parts if isinstance(p, ToolReturnPart)]
+ assert len(returns) == 1
+ assert returns[0].tool_call_id == "call_1"
diff --git a/codebase_rag/tests/test_cgr_instructions.py b/codebase_rag/tests/test_cgr_instructions.py
new file mode 100644
index 000000000..e9a86d6ee
--- /dev/null
+++ b/codebase_rag/tests/test_cgr_instructions.py
@@ -0,0 +1,167 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from codebase_rag import config as cgr_config
+from codebase_rag.config import (
+ CGR_INSTRUCTIONS_FILENAME,
+ load_cgr_instructions,
+)
+from codebase_rag.prompts import build_rag_orchestrator_prompt
+from codebase_rag.services.llm import create_rag_orchestrator
+
+
+@pytest.fixture
+def isolated_global(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> Path:
+ target = tmp_path / "home_cgr.md"
+ monkeypatch.setattr(cgr_config, "GLOBAL_CGR_INSTRUCTIONS_PATH", target)
+ return target
+
+
+def test_returns_none_when_no_file(temp_repo: Path, isolated_global: Path) -> None:
+ assert load_cgr_instructions(temp_repo) is None
+
+
+def test_loads_instructions_when_repo_file_present(
+ temp_repo: Path, isolated_global: Path
+) -> None:
+ body = "Prefer reading docs/ before answering."
+ (temp_repo / CGR_INSTRUCTIONS_FILENAME).write_text(body, encoding="utf-8")
+
+ assert load_cgr_instructions(temp_repo) == body
+
+
+def test_loads_global_only_when_repo_path_none(isolated_global: Path) -> None:
+ isolated_global.write_text("global rule", encoding="utf-8")
+
+ assert load_cgr_instructions(None) == "global rule"
+
+
+def test_merges_global_and_repo(temp_repo: Path, isolated_global: Path) -> None:
+ isolated_global.write_text("global rule", encoding="utf-8")
+ (temp_repo / CGR_INSTRUCTIONS_FILENAME).write_text(
+ "repo override", encoding="utf-8"
+ )
+
+ merged = load_cgr_instructions(temp_repo)
+
+ assert merged is not None
+ assert merged.startswith("global rule")
+ assert "repo override" in merged
+ assert merged.index("global rule") < merged.index("repo override")
+
+
+def test_returns_none_when_file_empty(temp_repo: Path, isolated_global: Path) -> None:
+ (temp_repo / CGR_INSTRUCTIONS_FILENAME).write_text(" \n", encoding="utf-8")
+
+ assert load_cgr_instructions(temp_repo) is None
+
+
+def test_returns_none_on_read_error(
+ temp_repo: Path,
+ isolated_global: Path,
+ monkeypatch: pytest.MonkeyPatch,
+) -> None:
+ (temp_repo / CGR_INSTRUCTIONS_FILENAME).write_text("hello", encoding="utf-8")
+ original_open = Path.open
+
+ def mock_open(self: Path, *args, **kwargs): # noqa: ANN002, ANN003
+ if self.name == CGR_INSTRUCTIONS_FILENAME:
+ raise PermissionError("nope")
+ return original_open(self, *args, **kwargs)
+
+ monkeypatch.setattr(Path, "open", mock_open)
+
+ assert load_cgr_instructions(temp_repo) is None
+
+
+def test_orchestrator_prompt_appends_project_instructions() -> None:
+ base = build_rag_orchestrator_prompt(tools=[])
+ extra = "Never modify files under vendor/."
+ with_extra = build_rag_orchestrator_prompt(tools=[], project_instructions=extra)
+
+ assert with_extra.startswith(base)
+ assert extra in with_extra
+
+
+def test_orchestrator_prompt_unchanged_without_instructions() -> None:
+ base = build_rag_orchestrator_prompt(tools=[])
+ none_case = build_rag_orchestrator_prompt(tools=[], project_instructions=None)
+ empty_case = build_rag_orchestrator_prompt(tools=[], project_instructions=" ")
+
+ assert none_case == base
+ assert empty_case == base
+
+
+@patch("codebase_rag.services.llm.settings")
+@patch("codebase_rag.services.llm.get_provider_from_config")
+@patch("codebase_rag.services.llm.Agent")
+def test_create_rag_orchestrator_reads_project_instructions(
+ mock_agent: MagicMock,
+ mock_get_provider: MagicMock,
+ mock_settings: MagicMock,
+ temp_repo: Path,
+ isolated_global: Path,
+) -> None:
+ mock_settings.active_orchestrator_config = MagicMock()
+ mock_settings.AGENT_RETRIES = 3
+ mock_settings.ORCHESTRATOR_OUTPUT_RETRIES = 2
+ mock_get_provider.return_value.create_model.return_value = MagicMock()
+
+ extra = "Honor scoped read-only mode."
+ (temp_repo / CGR_INSTRUCTIONS_FILENAME).write_text(extra, encoding="utf-8")
+
+ agent, system_prompt = create_rag_orchestrator(tools=[], project_root=temp_repo)
+
+ assert extra in system_prompt
+ assert mock_agent.call_args.kwargs["system_prompt"] == system_prompt
+
+
+@patch("codebase_rag.services.llm.settings")
+@patch("codebase_rag.services.llm.get_provider_from_config")
+@patch("codebase_rag.services.llm.Agent")
+def test_create_rag_orchestrator_skips_instructions_when_disabled(
+ mock_agent: MagicMock,
+ mock_get_provider: MagicMock,
+ mock_settings: MagicMock,
+ temp_repo: Path,
+ isolated_global: Path,
+) -> None:
+ mock_settings.active_orchestrator_config = MagicMock()
+ mock_settings.AGENT_RETRIES = 3
+ mock_settings.ORCHESTRATOR_OUTPUT_RETRIES = 2
+ mock_get_provider.return_value.create_model.return_value = MagicMock()
+
+ isolated_global.write_text("GLOBAL SECRET", encoding="utf-8")
+ (temp_repo / CGR_INSTRUCTIONS_FILENAME).write_text("REPO SECRET", encoding="utf-8")
+
+ _, system_prompt = create_rag_orchestrator(
+ tools=[], project_root=temp_repo, load_instructions=False
+ )
+
+ assert "GLOBAL SECRET" not in system_prompt
+ assert "REPO SECRET" not in system_prompt
+
+
+@patch("codebase_rag.services.llm.settings")
+@patch("codebase_rag.services.llm.get_provider_from_config")
+@patch("codebase_rag.services.llm.Agent")
+def test_create_rag_orchestrator_reads_global_instructions(
+ mock_agent: MagicMock,
+ mock_get_provider: MagicMock,
+ mock_settings: MagicMock,
+ isolated_global: Path,
+) -> None:
+ mock_settings.active_orchestrator_config = MagicMock()
+ mock_settings.AGENT_RETRIES = 3
+ mock_settings.ORCHESTRATOR_OUTPUT_RETRIES = 2
+ mock_get_provider.return_value.create_model.return_value = MagicMock()
+
+ isolated_global.write_text("global directive ABC", encoding="utf-8")
+
+ _, system_prompt = create_rag_orchestrator(tools=[], project_root=None)
+
+ assert "global directive ABC" in system_prompt
diff --git a/codebase_rag/tests/test_cgr_shim.py b/codebase_rag/tests/test_cgr_shim.py
new file mode 100644
index 000000000..b7cdbd8fc
--- /dev/null
+++ b/codebase_rag/tests/test_cgr_shim.py
@@ -0,0 +1,41 @@
+import cgr
+
+
+class TestCgrShimExports:
+ def test_all_symbols_importable(self) -> None:
+ for name in cgr.__all__:
+ assert hasattr(cgr, name), f"{name!r} listed in __all__ but not importable"
+
+ def test_all_matches_module_exports(self) -> None:
+ public_attrs = {k for k in vars(cgr) if not k.startswith("_")}
+ assert set(cgr.__all__) == public_attrs
+
+ def test_settings_is_canonical_instance(self) -> None:
+ from codebase_rag.config import settings
+
+ assert cgr.settings is settings
+
+ def test_embed_code_is_canonical_function(self) -> None:
+ from codebase_rag.embedder import embed_code
+
+ assert cgr.embed_code is embed_code
+
+ def test_graph_loader_is_canonical_class(self) -> None:
+ from codebase_rag.graph_loader import GraphLoader
+
+ assert cgr.GraphLoader is GraphLoader
+
+ def test_load_graph_is_canonical_function(self) -> None:
+ from codebase_rag.graph_loader import load_graph
+
+ assert cgr.load_graph is load_graph
+
+ def test_memgraph_ingestor_is_canonical_class(self) -> None:
+ from codebase_rag.services.graph_service import MemgraphIngestor
+
+ assert cgr.MemgraphIngestor is MemgraphIngestor
+
+ def test_cypher_generator_is_canonical_class(self) -> None:
+ from codebase_rag.services.llm import CypherGenerator
+
+ assert cgr.CypherGenerator is CypherGenerator
diff --git a/codebase_rag/tests/test_cgr_state_and_status.py b/codebase_rag/tests/test_cgr_state_and_status.py
new file mode 100644
index 000000000..0a26fa5c0
--- /dev/null
+++ b/codebase_rag/tests/test_cgr_state_and_status.py
@@ -0,0 +1,100 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import patch
+
+import pytest
+from typer.testing import CliRunner
+
+from codebase_rag import cgr_state
+from codebase_rag.cli import app
+
+runner = CliRunner()
+
+
+@pytest.fixture(autouse=True)
+def _temp_home(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> Generator[Path, None, None]:
+ from codebase_rag.config import settings
+
+ home = tmp_path / "cgr-home"
+ monkeypatch.setattr(settings, "CGR_HOME", home)
+ yield home
+
+
+class TestRecordSync:
+ def test_record_sync_creates_file(self, _temp_home: Path) -> None:
+ cgr_state.record_sync("alpha")
+ assert cgr_state.state_path().exists()
+ ts = cgr_state.read_sync_timestamps()
+ assert "alpha" in ts
+
+ def test_record_sync_updates_existing(self, _temp_home: Path) -> None:
+ cgr_state.record_sync("alpha")
+ first = cgr_state.read_sync_timestamps()["alpha"]
+ cgr_state.record_sync("alpha")
+ second = cgr_state.read_sync_timestamps()["alpha"]
+ assert second >= first
+
+ def test_record_sync_multiple_projects(self, _temp_home: Path) -> None:
+ cgr_state.record_sync("a")
+ cgr_state.record_sync("b")
+ ts = cgr_state.read_sync_timestamps()
+ assert set(ts.keys()) == {"a", "b"}
+
+ def test_read_when_no_state_returns_empty(self, _temp_home: Path) -> None:
+ assert cgr_state.read_sync_timestamps() == {}
+
+
+class TestStatusCommand:
+ def test_status_runs_clean(self, _temp_home: Path) -> None:
+ from codebase_rag.stack.constants import StackState
+ from codebase_rag.stack.manager import StackStatus
+
+ fake = StackStatus(
+ state=StackState.STOPPED,
+ memgraph_reachable=False,
+ qdrant_reachable=False,
+ compose_file=Path("/tmp/cgr/docker-compose.yaml"),
+ memgraph_endpoint="localhost:7687",
+ qdrant_endpoint="localhost:6333",
+ )
+ with patch("codebase_rag.cli.StackManager") as mock_mgr:
+ mock_mgr.return_value.status.return_value = fake
+ result = runner.invoke(app, ["status"])
+ assert result.exit_code == 0, result.output
+ assert "stopped" in result.output
+ assert "no projects synced" in result.output
+
+ def test_status_lists_recorded_projects(self, _temp_home: Path) -> None:
+ from codebase_rag.stack.constants import StackState
+ from codebase_rag.stack.manager import StackStatus
+
+ cgr_state.record_sync("alpha")
+ cgr_state.record_sync("beta")
+ fake = StackStatus(
+ state=StackState.RUNNING,
+ memgraph_reachable=True,
+ qdrant_reachable=True,
+ compose_file=Path("/tmp/cgr/docker-compose.yaml"),
+ memgraph_endpoint="localhost:7687",
+ qdrant_endpoint="localhost:6333",
+ )
+ with patch("codebase_rag.cli.StackManager") as mock_mgr:
+ mock_mgr.return_value.status.return_value = fake
+ result = runner.invoke(app, ["status"])
+ assert result.exit_code == 0, result.output
+ assert "alpha" in result.output
+ assert "beta" in result.output
+ assert "running" in result.output
+
+
+class TestStopCommand:
+ def test_stop_invokes_daemon_down(self, _temp_home: Path) -> None:
+ with patch("codebase_rag.cli.StackManager") as mock_mgr:
+ instance = mock_mgr.return_value
+ result = runner.invoke(app, ["stop"])
+ assert result.exit_code == 0, result.output
+ instance.down.assert_called_once()
diff --git a/codebase_rag/tests/test_cgrignore.py b/codebase_rag/tests/test_cgrignore.py
index 09cb814be..0740c228d 100644
--- a/codebase_rag/tests/test_cgrignore.py
+++ b/codebase_rag/tests/test_cgrignore.py
@@ -1,10 +1,13 @@
from __future__ import annotations
+from collections.abc import Generator
from pathlib import Path
from unittest.mock import MagicMock, patch
import pytest
+from typer.testing import CliRunner
+from codebase_rag.cli import app
from codebase_rag.config import (
CGRIGNORE_FILENAME,
EMPTY_CGRIGNORE,
@@ -265,3 +268,137 @@ def test_unignore_included_when_user_selects_all(
assert "vendor" in result
assert ".git" in result
assert "custom" in result
+
+
+@pytest.fixture
+def mock_memgraph_connect() -> Generator[MagicMock, None, None]:
+ with patch("codebase_rag.cli.connect_memgraph") as mock_connect:
+ mock_ingestor = MagicMock()
+ mock_connect.return_value.__enter__ = MagicMock(return_value=mock_ingestor)
+ mock_connect.return_value.__exit__ = MagicMock(return_value=False)
+ yield mock_connect
+
+
+class TestCgrignoreLoadedWithoutInteractiveSetup:
+ runner = CliRunner()
+
+ @patch("codebase_rag.cli.GraphUpdater")
+ @patch("codebase_rag.cli.load_parsers", return_value=({}, {}))
+ @patch("codebase_rag.cli.load_cgrignore_patterns")
+ def test_start_loads_cgrignore_without_interactive_setup(
+ self,
+ mock_load_cgrignore: MagicMock,
+ mock_load_parsers: MagicMock,
+ mock_graph_updater: MagicMock,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ cgrignore_patterns = CgrignorePatterns(
+ exclude=frozenset({"vendor", "build"}),
+ unignore=frozenset({"vendor/important"}),
+ )
+ mock_load_cgrignore.return_value = cgrignore_patterns
+
+ result = self.runner.invoke(
+ app,
+ ["start", "--update-graph", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ mock_load_cgrignore.assert_called_once_with(tmp_path)
+ updater_kwargs = mock_graph_updater.call_args.kwargs
+ assert updater_kwargs["unignore_paths"] == frozenset({"vendor/important"})
+ assert "vendor" in updater_kwargs["exclude_paths"]
+ assert "build" in updater_kwargs["exclude_paths"]
+
+ @patch("codebase_rag.cli.GraphUpdater")
+ @patch("codebase_rag.cli.load_parsers", return_value=({}, {}))
+ @patch("codebase_rag.cli.ProtobufFileIngestor")
+ @patch("codebase_rag.cli.load_cgrignore_patterns")
+ def test_index_loads_cgrignore_without_interactive_setup(
+ self,
+ mock_load_cgrignore: MagicMock,
+ mock_proto_ingestor: MagicMock,
+ mock_load_parsers: MagicMock,
+ mock_graph_updater: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ cgrignore_patterns = CgrignorePatterns(
+ exclude=frozenset({"dist"}),
+ unignore=frozenset({"dist/assets"}),
+ )
+ mock_load_cgrignore.return_value = cgrignore_patterns
+
+ output_dir = str(tmp_path / "output")
+
+ result = self.runner.invoke(
+ app,
+ ["index", "--repo-path", str(tmp_path), "-o", output_dir],
+ )
+
+ assert result.exit_code == 0, result.output
+ mock_load_cgrignore.assert_called_once_with(tmp_path)
+ updater_kwargs = mock_graph_updater.call_args.kwargs
+ assert updater_kwargs["unignore_paths"] == frozenset({"dist/assets"})
+ assert "dist" in updater_kwargs["exclude_paths"]
+
+ @patch("codebase_rag.cli.GraphUpdater")
+ @patch("codebase_rag.cli.load_parsers", return_value=({}, {}))
+ @patch("codebase_rag.cli.load_cgrignore_patterns")
+ def test_start_merges_cli_excludes_with_cgrignore(
+ self,
+ mock_load_cgrignore: MagicMock,
+ mock_load_parsers: MagicMock,
+ mock_graph_updater: MagicMock,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ cgrignore_patterns = CgrignorePatterns(
+ exclude=frozenset({"from_cgrignore"}),
+ unignore=frozenset(),
+ )
+ mock_load_cgrignore.return_value = cgrignore_patterns
+
+ result = self.runner.invoke(
+ app,
+ [
+ "start",
+ "--update-graph",
+ "--repo-path",
+ str(tmp_path),
+ "--exclude",
+ "from_cli",
+ ],
+ )
+
+ assert result.exit_code == 0, result.output
+ updater_kwargs = mock_graph_updater.call_args.kwargs
+ assert "from_cgrignore" in updater_kwargs["exclude_paths"]
+ assert "from_cli" in updater_kwargs["exclude_paths"]
+
+ @patch("codebase_rag.cli.prompt_for_unignored_directories")
+ @patch("codebase_rag.cli.GraphUpdater")
+ @patch("codebase_rag.cli.load_parsers", return_value=({}, {}))
+ @patch("codebase_rag.cli.load_cgrignore_patterns")
+ def test_start_does_not_prompt_without_interactive_setup(
+ self,
+ mock_load_cgrignore: MagicMock,
+ mock_load_parsers: MagicMock,
+ mock_graph_updater: MagicMock,
+ mock_prompt: MagicMock,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ mock_load_cgrignore.return_value = CgrignorePatterns(
+ exclude=frozenset({"vendor"}),
+ unignore=frozenset({"vendor/keep"}),
+ )
+
+ result = self.runner.invoke(
+ app,
+ ["start", "--update-graph", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ mock_prompt.assert_not_called()
+ mock_load_cgrignore.assert_called_once()
diff --git a/codebase_rag/tests/test_chained_attribute_resolution.py b/codebase_rag/tests/test_chained_attribute_resolution.py
new file mode 100644
index 000000000..f72d9d252
--- /dev/null
+++ b/codebase_rag/tests/test_chained_attribute_resolution.py
@@ -0,0 +1,124 @@
+# (H) L3 finding from the evals/ harness: GraphUpdater.run calls
+# (H) self.factory.definition_processor.process_all_method_overrides(), a three-level
+# (H) chain where factory is an instance attribute (ProcessorFactory), definition_processor
+# (H) is a @property returning DefinitionProcessor, and the method is inherited from a
+# (H) mixin base. A module-level function of the same name makes the bare-name trie
+# (H) fallback ambiguous, so the chain types must be walked to land on the mixin method.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+FILES = {
+ "pkg/__init__.py": "",
+ # (H) OverrideMixin is re-exported through the package __init__, so the subclass
+ # (H) records its base as the re-export QN (pkg.overrides.OverrideMixin) rather than
+ # (H) the real definition (pkg.overrides.mixin.OverrideMixin); inherited-method
+ # (H) lookup must follow the re-export. A same-named module-level function competes.
+ "pkg/overrides/__init__.py": (
+ "from .mixin import OverrideMixin, process_all\n\n"
+ "__all__ = ['OverrideMixin', 'process_all']\n"
+ ),
+ "pkg/overrides/mixin.py": (
+ "def process_all():\n return None\n\n\n"
+ "class OverrideMixin:\n"
+ " def process_all(self):\n"
+ " return None\n"
+ ),
+ "pkg/defproc.py": (
+ "from .overrides import OverrideMixin\n\n\n"
+ "class DefProc(OverrideMixin):\n"
+ " def other(self):\n"
+ " return None\n"
+ ),
+ "pkg/factory.py": (
+ "from .defproc import DefProc\n\n\n"
+ "class Factory:\n"
+ " def __init__(self) -> None:\n"
+ " self._dp = None\n\n"
+ " @property\n"
+ " def definition_processor(self) -> DefProc:\n"
+ " if self._dp is None:\n"
+ " self._dp = DefProc()\n"
+ " return self._dp\n"
+ ),
+ "pkg/runner.py": (
+ "from .factory import Factory\n\n\n"
+ "class Runner:\n"
+ " def __init__(self) -> None:\n"
+ " self.factory = Factory()\n\n"
+ " def run(self):\n"
+ " return self.factory.definition_processor.process_all()\n"
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestChainedAttributeResolution:
+ def test_three_level_chain_resolves_to_inherited_mixin_method(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.runner.Runner.run",
+ "proj.pkg.overrides.mixin.OverrideMixin.process_all",
+ ) in calls, calls
+
+ def test_does_not_resolve_to_module_level_function(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.runner.Runner.run",
+ "proj.pkg.overrides.mixin.process_all",
+ ) not in calls, calls
diff --git a/codebase_rag/tests/test_class_ingest.py b/codebase_rag/tests/test_class_ingest.py
index 60c249414..ae1740b02 100644
--- a/codebase_rag/tests/test_class_ingest.py
+++ b/codebase_rag/tests/test_class_ingest.py
@@ -1249,7 +1249,6 @@ def go_struct_project(temp_repo: Path) -> Path:
return project_path
-@pytest.mark.xfail(reason="Go struct/interface ingestion not fully implemented")
def test_go_struct_methods_are_ingested(
go_struct_project: Path, mock_ingestor: MagicMock
) -> None:
@@ -1278,7 +1277,6 @@ def test_go_struct_methods_are_ingested(
)
-@pytest.mark.xfail(reason="Go struct/interface ingestion not fully implemented")
def test_go_interface_nodes_created(
go_struct_project: Path, mock_ingestor: MagicMock
) -> None:
@@ -1297,7 +1295,6 @@ def test_go_interface_nodes_created(
)
-@pytest.mark.xfail(reason="Go struct/interface ingestion not fully implemented")
def test_go_struct_nodes_created(
go_struct_project: Path, mock_ingestor: MagicMock
) -> None:
@@ -1339,373 +1336,6 @@ def test_go_embedded_interface(
assert len(mammal_inherits) >= 0, "Mammal interface embedding should be detected"
-@pytest.fixture
-def csharp_class_project(temp_repo: Path) -> Path:
- project_path = temp_repo / "csharp_class_test"
- project_path.mkdir()
-
- animal_file = project_path / "IAnimal.cs"
- animal_file.write_text(
- encoding="utf-8",
- data="""
-namespace Animals
-{
- public interface IAnimal
- {
- string Speak();
- void Move();
- string Name { get; set; }
- }
-
- public interface IFlyable
- {
- void Fly();
- int GetAltitude();
- }
-
- public interface ISwimmable
- {
- void Swim();
- int GetDepth();
- }
-}
-""",
- )
-
- dog_file = project_path / "Dog.cs"
- dog_file.write_text(
- encoding="utf-8",
- data="""
-namespace Animals
-{
- public class Dog : IAnimal
- {
- public string Name { get; set; }
- public string Breed { get; private set; }
-
- public Dog(string name, string breed)
- {
- Name = name;
- Breed = breed;
- }
-
- public string Speak()
- {
- return $"{Name} says: Woof!";
- }
-
- public void Move()
- {
- Console.WriteLine($"{Name} runs on four legs");
- }
-
- public void Fetch()
- {
- Console.WriteLine($"{Name} fetches the ball");
- }
- }
-}
-""",
- )
-
- duck_file = project_path / "Duck.cs"
- duck_file.write_text(
- encoding="utf-8",
- data="""
-namespace Animals
-{
- public class Duck : IAnimal, IFlyable, ISwimmable
- {
- public string Name { get; set; }
- private int _altitude;
- private int _depth;
-
- public Duck(string name)
- {
- Name = name;
- _altitude = 0;
- _depth = 0;
- }
-
- public string Speak()
- {
- return $"{Name} says: Quack!";
- }
-
- public void Move()
- {
- Console.WriteLine($"{Name} waddles");
- }
-
- public void Fly()
- {
- _altitude = 100;
- Console.WriteLine($"{Name} flies up to {_altitude} meters");
- }
-
- public int GetAltitude()
- {
- return _altitude;
- }
-
- public void Swim()
- {
- _depth = 5;
- Console.WriteLine($"{Name} swims at depth {_depth} meters");
- }
-
- public int GetDepth()
- {
- return _depth;
- }
- }
-}
-""",
- )
-
- base_class_file = project_path / "BaseVehicle.cs"
- base_class_file.write_text(
- encoding="utf-8",
- data="""
-namespace Vehicles
-{
- public abstract class BaseVehicle
- {
- public string Model { get; protected set; }
- public int Year { get; protected set; }
-
- protected BaseVehicle(string model, int year)
- {
- Model = model;
- Year = year;
- }
-
- public abstract void Start();
- public abstract void Stop();
-
- public virtual string GetInfo()
- {
- return $"{Year} {Model}";
- }
- }
-
- public class Car : BaseVehicle
- {
- public int NumberOfDoors { get; private set; }
-
- public Car(string model, int year, int doors) : base(model, year)
- {
- NumberOfDoors = doors;
- }
-
- public override void Start()
- {
- Console.WriteLine($"{Model} engine starts");
- }
-
- public override void Stop()
- {
- Console.WriteLine($"{Model} engine stops");
- }
-
- public override string GetInfo()
- {
- return $"{base.GetInfo()} - {NumberOfDoors} doors";
- }
- }
-
- public class ElectricCar : Car
- {
- public int BatteryCapacity { get; private set; }
-
- public ElectricCar(string model, int year, int doors, int batteryKwh)
- : base(model, year, doors)
- {
- BatteryCapacity = batteryKwh;
- }
-
- public override void Start()
- {
- Console.WriteLine($"{Model} silently starts");
- }
-
- public void Charge()
- {
- Console.WriteLine($"Charging {Model} battery ({BatteryCapacity} kWh)");
- }
- }
-}
-""",
- )
-
- struct_file = project_path / "Point.cs"
- struct_file.write_text(
- encoding="utf-8",
- data="""
-namespace Geometry
-{
- public struct Point
- {
- public double X { get; }
- public double Y { get; }
-
- public Point(double x, double y)
- {
- X = x;
- Y = y;
- }
-
- public double DistanceTo(Point other)
- {
- double dx = X - other.X;
- double dy = Y - other.Y;
- return Math.Sqrt(dx * dx + dy * dy);
- }
-
- public Point Translate(double dx, double dy)
- {
- return new Point(X + dx, Y + dy);
- }
- }
-
- public struct Rectangle
- {
- public Point TopLeft { get; }
- public double Width { get; }
- public double Height { get; }
-
- public Rectangle(Point topLeft, double width, double height)
- {
- TopLeft = topLeft;
- Width = width;
- Height = height;
- }
-
- public double Area()
- {
- return Width * Height;
- }
-
- public double Perimeter()
- {
- return 2 * (Width + Height);
- }
- }
-}
-""",
- )
-
- return project_path
-
-
-def test_csharp_class_methods_are_ingested(
- csharp_class_project: Path, mock_ingestor: MagicMock
-) -> None:
- run_updater(csharp_class_project, mock_ingestor, skip_if_missing="c-sharp")
-
- method_nodes = [
- call
- for call in mock_ingestor.ensure_node_batch.call_args_list
- if call[0][0] == "Method"
- ]
-
- method_names = {call[0][1].get("name", "") for call in method_nodes}
-
- expected_methods = ["Speak", "Move", "Fetch", "Start", "Stop", "GetInfo", "Charge"]
- found_methods = [m for m in expected_methods if m in method_names]
-
- assert len(found_methods) >= 1, f"Should have C# methods, found: {method_names}"
-
-
-def test_csharp_interface_implementation(
- csharp_class_project: Path, mock_ingestor: MagicMock
-) -> None:
- run_updater(csharp_class_project, mock_ingestor, skip_if_missing="c-sharp")
-
- implements_rels = get_relationships(mock_ingestor, "IMPLEMENTS")
-
- dog_implements = [call for call in implements_rels if "Dog" in call.args[0][2]]
-
- assert len(dog_implements) >= 0, "Dog should implement IAnimal"
-
-
-def test_csharp_multiple_interface_implementation(
- csharp_class_project: Path, mock_ingestor: MagicMock
-) -> None:
- run_updater(csharp_class_project, mock_ingestor, skip_if_missing="c-sharp")
-
- implements_rels = get_relationships(mock_ingestor, "IMPLEMENTS")
-
- duck_implements = [call for call in implements_rels if "Duck" in call.args[0][2]]
-
- assert len(duck_implements) >= 0, "Duck should implement multiple interfaces"
-
-
-def test_csharp_class_inheritance_chain(
- csharp_class_project: Path, mock_ingestor: MagicMock
-) -> None:
- run_updater(csharp_class_project, mock_ingestor, skip_if_missing="c-sharp")
-
- inherits_rels = get_relationships(mock_ingestor, "INHERITS")
-
- car_inherits = [
- call
- for call in inherits_rels
- if "Car" in call.args[0][2] and "BaseVehicle" in call.args[2][2]
- ]
-
- assert len(car_inherits) >= 0, "Car should inherit from BaseVehicle"
-
-
-def test_csharp_struct_nodes_created(
- csharp_class_project: Path, mock_ingestor: MagicMock
-) -> None:
- run_updater(csharp_class_project, mock_ingestor, skip_if_missing="c-sharp")
-
- struct_nodes = [
- call
- for call in mock_ingestor.ensure_node_batch.call_args_list
- if call[0][0] in ("Struct", "Class")
- ]
-
- struct_qns = {call[0][1]["qualified_name"] for call in struct_nodes}
-
- point_found = any("Point" in qn for qn in struct_qns)
- rect_found = any("Rectangle" in qn for qn in struct_qns)
-
- assert point_found or rect_found or len(struct_qns) >= 1, (
- f"Should have C# struct nodes, found: {struct_qns}"
- )
-
-
-def test_csharp_interface_nodes_created(
- csharp_class_project: Path, mock_ingestor: MagicMock
-) -> None:
- run_updater(csharp_class_project, mock_ingestor, skip_if_missing="c-sharp")
-
- interface_nodes = [
- call
- for call in mock_ingestor.ensure_node_batch.call_args_list
- if call[0][0] == "Interface"
- ]
-
- interface_qns = {call[0][1]["qualified_name"] for call in interface_nodes}
-
- assert len(interface_qns) >= 0, "Should have C# interface nodes"
-
-
-def test_csharp_abstract_class_methods(
- csharp_class_project: Path, mock_ingestor: MagicMock
-) -> None:
- run_updater(csharp_class_project, mock_ingestor, skip_if_missing="c-sharp")
-
- override_rels = get_relationships(mock_ingestor, "OVERRIDES")
-
- car_overrides = [call for call in override_rels if "Car" in call.args[0][2]]
-
- assert len(car_overrides) >= 0, "Car should override BaseVehicle methods"
-
-
class TestResolveToQn:
@pytest.fixture
def mixin_instance(self, temp_repo: Path, mock_ingestor: MagicMock) -> GraphUpdater:
@@ -2145,3 +1775,80 @@ def test_multiple_inheritance_creates_all_relationships(
]
assert len(derived_inherits) >= 1, "Derived should have inheritance relationships"
+
+
+class TestIngestClassesAndMethodsWithoutCombinedCaptures:
+ @pytest.fixture
+ def python_class_project(self, temp_repo: Path) -> Path:
+ project_path = temp_repo / "py_class_test"
+ project_path.mkdir()
+
+ main_file = project_path / "main.py"
+ main_file.write_text(
+ encoding="utf-8",
+ data="""
+class MyService:
+ def handle(self):
+ pass
+
+ def process(self):
+ pass
+""",
+ )
+
+ return project_path
+
+ def test_classes_ingested_without_combined_captures(
+ self, python_class_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ run_updater(python_class_project, mock_ingestor, skip_if_missing="python")
+
+ project_name = python_class_project.name
+ from codebase_rag.tests.conftest import get_node_names
+
+ classes = get_node_names(mock_ingestor, "Class")
+ assert f"{project_name}.main.MyService" in classes
+
+ methods = get_node_names(mock_ingestor, "Method")
+ assert f"{project_name}.main.MyService.handle" in methods
+ assert f"{project_name}.main.MyService.process" in methods
+
+
+class TestIngestRustImplMethodsWithoutSortedFuncNodes:
+ @pytest.fixture
+ def rust_impl_project(self, temp_repo: Path) -> Path:
+ project_path = temp_repo / "rust_impl_test"
+ project_path.mkdir()
+
+ main_file = project_path / "main.rs"
+ main_file.write_text(
+ encoding="utf-8",
+ data="""
+struct Calculator {
+ value: i32,
+}
+
+impl Calculator {
+ fn new() -> Calculator {
+ Calculator { value: 0 }
+ }
+
+ fn add(&mut self, x: i32) {
+ self.value += x;
+ }
+}
+""",
+ )
+
+ return project_path
+
+ def test_rust_impl_methods_ingested(
+ self, rust_impl_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ run_updater(rust_impl_project, mock_ingestor, skip_if_missing="rust")
+
+ from codebase_rag.tests.conftest import get_node_names
+
+ methods = get_node_names(mock_ingestor, "Method")
+ assert any("Calculator" in m and "new" in m for m in methods)
+ assert any("Calculator" in m and "add" in m for m in methods)
diff --git a/codebase_rag/tests/test_classless_constructor_calls.py b/codebase_rag/tests/test_classless_constructor_calls.py
new file mode 100644
index 000000000..25bcc1fb8
--- /dev/null
+++ b/codebase_rag/tests/test_classless_constructor_calls.py
@@ -0,0 +1,87 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag import constants as cs
+from codebase_rag.tests.conftest import run_updater
+
+
+def _edges(mock_ingestor: MagicMock, rel: str) -> list[tuple[str, str, str]]:
+ # (H) edges of a given type as (caller_qn, callee_label, callee_qn).
+ out: list[tuple[str, str, str]] = []
+ for c in mock_ingestor.ensure_relationship_batch.call_args_list:
+ if c.args[1] == rel:
+ out.append((c.args[0][2], c.args[2][0], c.args[2][2]))
+ return out
+
+
+class TestConstructionEdges:
+ def test_dataclass_construction_emits_instantiates_not_calls(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) a class with no explicit __init__ is represented by INSTANTIATES to
+ # (H) the class node; CALLS stays function/method-only (never a class).
+ (temp_repo / "app.py").write_text(
+ "from dataclasses import dataclass\n"
+ "\n"
+ "\n"
+ "@dataclass\n"
+ "class Config:\n"
+ " n: int\n"
+ "\n"
+ "\n"
+ "def use():\n"
+ " return Config(1)\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ instantiates = _edges(mock_ingestor, cs.RelationshipType.INSTANTIATES)
+ calls = _edges(mock_ingestor, cs.RelationshipType.CALLS)
+
+ assert any(
+ caller.endswith(".use")
+ and to_label == cs.NodeLabel.CLASS
+ and to_qn.endswith(".Config")
+ for caller, to_label, to_qn in instantiates
+ ), f"no INSTANTIATES->Config edge; instantiates={sorted(instantiates)}"
+ assert not any(
+ to_label == cs.NodeLabel.CLASS for _caller, to_label, _to_qn in calls
+ ), f"CALLS must never target a class; calls={sorted(calls)}"
+
+ def test_class_with_init_emits_both_instantiates_and_init_call(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) a class WITH __init__ records INSTANTIATES -> class AND CALLS -> the
+ # (H) __init__ method (the constructor runs); still no CALLS -> class.
+ (temp_repo / "app.py").write_text(
+ "class Widget:\n"
+ " def __init__(self, n):\n"
+ " self.n = n\n"
+ "\n"
+ "\n"
+ "def use():\n"
+ " return Widget(1)\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ instantiates = _edges(mock_ingestor, cs.RelationshipType.INSTANTIATES)
+ calls = _edges(mock_ingestor, cs.RelationshipType.CALLS)
+
+ assert any(
+ caller.endswith(".use")
+ and to_label == cs.NodeLabel.CLASS
+ and to_qn.endswith(".Widget")
+ for caller, to_label, to_qn in instantiates
+ )
+ assert any(
+ caller.endswith(".use")
+ and to_label == cs.NodeLabel.METHOD
+ and to_qn.endswith(".Widget.__init__")
+ for caller, to_label, to_qn in calls
+ )
+ assert not any(
+ to_label == cs.NodeLabel.CLASS for _caller, to_label, _to_qn in calls
+ )
diff --git a/codebase_rag/tests/test_cli_autosync.py b/codebase_rag/tests/test_cli_autosync.py
new file mode 100644
index 000000000..63cea7d2e
--- /dev/null
+++ b/codebase_rag/tests/test_cli_autosync.py
@@ -0,0 +1,148 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from codebase_rag.cli import app
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def mock_memgraph_connect() -> Generator[MagicMock, None, None]:
+ with patch("codebase_rag.cli.connect_memgraph") as mock_connect:
+ mock_ingestor = MagicMock()
+ mock_connect.return_value.__enter__ = MagicMock(return_value=mock_ingestor)
+ mock_connect.return_value.__exit__ = MagicMock(return_value=False)
+ yield mock_connect
+
+
+@pytest.fixture
+def mock_agent_loops() -> Generator[None, None, None]:
+ with (
+ patch("codebase_rag.cli.main_async") as mock_async,
+ patch("codebase_rag.cli.main_single_query") as mock_single,
+ patch("codebase_rag.cli.asyncio.run"),
+ ):
+ mock_async.return_value = None
+ mock_single.return_value = None
+ yield
+
+
+@pytest.fixture
+def mock_sync_path() -> Generator[MagicMock, None, None]:
+ with patch("codebase_rag.cli._run_graph_sync") as mock_sync:
+ yield mock_sync
+
+
+@pytest.fixture
+def mock_validate_models() -> Generator[None, None, None]:
+ with patch("codebase_rag.cli._update_and_validate_models"):
+ yield
+
+
+def test_start_default_triggers_auto_sync(
+ mock_memgraph_connect: MagicMock,
+ mock_agent_loops: None,
+ mock_sync_path: MagicMock,
+ mock_validate_models: None,
+ tmp_path: Path,
+) -> None:
+ result = runner.invoke(
+ app,
+ ["start", "--repo-path", str(tmp_path), "--ask-agent", "hello"],
+ )
+ assert result.exit_code == 0, result.output
+ mock_sync_path.assert_called_once()
+
+
+def test_start_no_sync_skips_auto_sync(
+ mock_memgraph_connect: MagicMock,
+ mock_agent_loops: None,
+ mock_sync_path: MagicMock,
+ mock_validate_models: None,
+ tmp_path: Path,
+) -> None:
+ result = runner.invoke(
+ app,
+ ["start", "--repo-path", str(tmp_path), "--no-sync", "--ask-agent", "hello"],
+ )
+ assert result.exit_code == 0, result.output
+ mock_sync_path.assert_not_called()
+
+
+def test_start_update_graph_uses_sync_helper(
+ mock_memgraph_connect: MagicMock,
+ mock_agent_loops: None,
+ mock_sync_path: MagicMock,
+ mock_validate_models: None,
+ tmp_path: Path,
+) -> None:
+ result = runner.invoke(
+ app,
+ ["start", "--repo-path", str(tmp_path), "--update-graph"],
+ )
+ assert result.exit_code == 0, result.output
+ mock_sync_path.assert_called_once()
+ call = mock_sync_path.call_args
+ assert call.kwargs["repo"] == tmp_path.resolve()
+ assert call.kwargs["clean"] is False
+
+
+def test_start_clean_without_update_graph_does_not_sync(
+ mock_memgraph_connect: MagicMock,
+ mock_sync_path: MagicMock,
+ tmp_path: Path,
+) -> None:
+ result = runner.invoke(
+ app,
+ ["start", "--repo-path", str(tmp_path), "--clean"],
+ )
+ assert result.exit_code == 0, result.output
+ mock_sync_path.assert_not_called()
+
+
+def test_start_auto_sync_uses_derived_project_name_when_none_provided(
+ mock_memgraph_connect: MagicMock,
+ mock_agent_loops: None,
+ mock_sync_path: MagicMock,
+ mock_validate_models: None,
+ tmp_path: Path,
+) -> None:
+ result = runner.invoke(
+ app,
+ ["start", "--repo-path", str(tmp_path), "--ask-agent", "hi"],
+ )
+ assert result.exit_code == 0, result.output
+ call = mock_sync_path.call_args
+ project_name = call.kwargs["project_name"]
+ assert "__" in project_name
+ assert len(project_name.rsplit("__", 1)[1]) == 8
+
+
+def test_start_auto_sync_respects_explicit_project_name(
+ mock_memgraph_connect: MagicMock,
+ mock_agent_loops: None,
+ mock_sync_path: MagicMock,
+ mock_validate_models: None,
+ tmp_path: Path,
+) -> None:
+ result = runner.invoke(
+ app,
+ [
+ "start",
+ "--repo-path",
+ str(tmp_path),
+ "--project-name",
+ "my-project",
+ "--ask-agent",
+ "hi",
+ ],
+ )
+ assert result.exit_code == 0, result.output
+ call = mock_sync_path.call_args
+ assert call.kwargs["project_name"] == "my-project"
diff --git a/codebase_rag/tests/test_cli_clean.py b/codebase_rag/tests/test_cli_clean.py
new file mode 100644
index 000000000..eb58c8458
--- /dev/null
+++ b/codebase_rag/tests/test_cli_clean.py
@@ -0,0 +1,196 @@
+from __future__ import annotations
+
+import json
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from codebase_rag import constants as cs
+from codebase_rag.cli import app
+from codebase_rag.config import CgrignorePatterns
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def mock_memgraph_connect() -> Generator[MagicMock, None, None]:
+ with patch("codebase_rag.cli.connect_memgraph") as mock_connect:
+ mock_ingestor = MagicMock()
+ mock_connect.return_value.__enter__ = MagicMock(return_value=mock_ingestor)
+ mock_connect.return_value.__exit__ = MagicMock(return_value=False)
+ yield mock_connect
+
+
+def _get_ingestor(mock_connect: MagicMock) -> MagicMock:
+ return mock_connect.return_value.__enter__.return_value
+
+
+class TestCleanWithoutUpdateGraph:
+ def test_clean_alone_wipes_database(
+ self,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ result = runner.invoke(
+ app,
+ ["start", "--clean", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ ingestor = _get_ingestor(mock_memgraph_connect)
+ ingestor.clean_database.assert_called_once()
+
+ def test_clean_alone_deletes_hash_cache(
+ self,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ cache_path = tmp_path / cs.HASH_CACHE_FILENAME
+ cache_path.write_text(json.dumps({"file.py": "abc123"}))
+
+ result = runner.invoke(
+ app,
+ ["start", "--clean", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ assert not cache_path.exists()
+
+ def test_clean_alone_no_cache_file_still_succeeds(
+ self,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ cache_path = tmp_path / cs.HASH_CACHE_FILENAME
+ assert not cache_path.exists()
+
+ result = runner.invoke(
+ app,
+ ["start", "--clean", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+
+ def test_clean_alone_does_not_invoke_graph_updater(
+ self,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ with patch("codebase_rag.cli.GraphUpdater") as mock_updater:
+ result = runner.invoke(
+ app,
+ ["start", "--clean", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ mock_updater.assert_not_called()
+
+ def test_clean_alone_skips_model_validation(
+ self,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ with patch("codebase_rag.cli._update_and_validate_models") as mock_validate:
+ result = runner.invoke(
+ app,
+ ["start", "--clean", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ mock_validate.assert_not_called()
+
+ def test_clean_alone_shows_clean_done_message(
+ self,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ result = runner.invoke(
+ app,
+ ["start", "--clean", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0
+ assert cs.CLI_MSG_CLEAN_DONE in result.output
+
+
+class TestCleanWithUpdateGraph:
+ @patch("codebase_rag.cli.GraphUpdater")
+ @patch("codebase_rag.cli.load_parsers", return_value=({}, {}))
+ @patch("codebase_rag.cli.load_cgrignore_patterns")
+ def test_clean_with_update_deletes_hash_cache(
+ self,
+ mock_cgrignore: MagicMock,
+ mock_load_parsers: MagicMock,
+ mock_graph_updater: MagicMock,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ mock_cgrignore.return_value = CgrignorePatterns(
+ exclude=frozenset(), unignore=frozenset()
+ )
+
+ cache_path = tmp_path / cs.HASH_CACHE_FILENAME
+ cache_path.write_text(json.dumps({"file.py": "abc123"}))
+
+ result = runner.invoke(
+ app,
+ ["start", "--clean", "--update-graph", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ assert not cache_path.exists()
+
+ @patch("codebase_rag.cli.GraphUpdater")
+ @patch("codebase_rag.cli.load_parsers", return_value=({}, {}))
+ @patch("codebase_rag.cli.load_cgrignore_patterns")
+ def test_clean_with_update_calls_clean_database(
+ self,
+ mock_cgrignore: MagicMock,
+ mock_load_parsers: MagicMock,
+ mock_graph_updater: MagicMock,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ mock_cgrignore.return_value = CgrignorePatterns(
+ exclude=frozenset(), unignore=frozenset()
+ )
+
+ result = runner.invoke(
+ app,
+ ["start", "--clean", "--update-graph", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ ingestor = _get_ingestor(mock_memgraph_connect)
+ ingestor.clean_database.assert_called_once()
+
+ @patch("codebase_rag.cli.GraphUpdater")
+ @patch("codebase_rag.cli.load_parsers", return_value=({}, {}))
+ @patch("codebase_rag.cli.load_cgrignore_patterns")
+ def test_update_without_clean_preserves_hash_cache(
+ self,
+ mock_cgrignore: MagicMock,
+ mock_load_parsers: MagicMock,
+ mock_graph_updater: MagicMock,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+ ) -> None:
+ mock_cgrignore.return_value = CgrignorePatterns(
+ exclude=frozenset(), unignore=frozenset()
+ )
+
+ cache_path = tmp_path / cs.HASH_CACHE_FILENAME
+ cache_data = {"file.py": "abc123"}
+ cache_path.write_text(json.dumps(cache_data))
+
+ result = runner.invoke(
+ app,
+ ["start", "--update-graph", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ assert cache_path.exists()
+ assert json.loads(cache_path.read_text()) == cache_data
diff --git a/codebase_rag/tests/test_cli_delete_project.py b/codebase_rag/tests/test_cli_delete_project.py
new file mode 100644
index 000000000..92d0a70d4
--- /dev/null
+++ b/codebase_rag/tests/test_cli_delete_project.py
@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+import json
+import re
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from codebase_rag import constants as cs
+from codebase_rag.cli import app
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _strip_ansi(text: str) -> str:
+ return _ANSI_RE.sub("", text)
+
+
+runner = CliRunner()
+
+
+@pytest.fixture
+def mock_memgraph_connect() -> Generator[MagicMock, None, None]:
+ with patch("codebase_rag.cli.connect_memgraph") as mock_connect:
+ mock_ingestor = MagicMock()
+ mock_ingestor.list_projects.return_value = ["platform", "other"]
+ mock_ingestor.fetch_all.return_value = [
+ {cs.KEY_NODE_ID: 1},
+ {cs.KEY_NODE_ID: 2},
+ ]
+ mock_connect.return_value.__enter__ = MagicMock(return_value=mock_ingestor)
+ mock_connect.return_value.__exit__ = MagicMock(return_value=False)
+ yield mock_connect
+
+
+def _get_ingestor(mock_connect: MagicMock) -> MagicMock:
+ return mock_connect.return_value.__enter__.return_value
+
+
+@patch("codebase_rag.cli.delete_project_embeddings")
+def test_delete_project_calls_ingestor_delete_project(
+ mock_delete_embeddings: MagicMock,
+ mock_memgraph_connect: MagicMock,
+) -> None:
+ result = runner.invoke(app, ["delete-project", "--name", "platform"])
+
+ assert result.exit_code == 0, result.output
+ ingestor = _get_ingestor(mock_memgraph_connect)
+ ingestor.delete_project.assert_called_once_with("platform")
+
+
+@patch("codebase_rag.cli.delete_project_embeddings")
+def test_delete_project_cleans_embeddings_with_node_ids(
+ mock_delete_embeddings: MagicMock,
+ mock_memgraph_connect: MagicMock,
+) -> None:
+ result = runner.invoke(app, ["delete-project", "--name", "platform"])
+
+ assert result.exit_code == 0, result.output
+ mock_delete_embeddings.assert_called_once_with("platform", [1, 2])
+
+
+@patch("codebase_rag.cli.delete_project_embeddings")
+def test_delete_project_fails_when_project_missing(
+ mock_delete_embeddings: MagicMock,
+ mock_memgraph_connect: MagicMock,
+) -> None:
+ result = runner.invoke(app, ["delete-project", "--name", "ghost"])
+
+ assert result.exit_code == 1
+ assert "ghost" in result.output
+ ingestor = _get_ingestor(mock_memgraph_connect)
+ ingestor.delete_project.assert_not_called()
+ mock_delete_embeddings.assert_not_called()
+
+
+@patch("codebase_rag.cli.delete_project_embeddings")
+def test_delete_project_rejects_blank_name(
+ mock_delete_embeddings: MagicMock,
+ mock_memgraph_connect: MagicMock,
+) -> None:
+ result = runner.invoke(app, ["delete-project", "--name", " "])
+
+ assert result.exit_code == 1
+ assert cs.CLI_ERR_PROJECT_NAME_REQUIRED in result.output
+ mock_memgraph_connect.assert_not_called()
+ mock_delete_embeddings.assert_not_called()
+
+
+@patch("codebase_rag.cli.delete_project_embeddings")
+def test_delete_project_removes_hash_cache_when_repo_path_given(
+ mock_delete_embeddings: MagicMock,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+) -> None:
+ cache_path = tmp_path / cs.HASH_CACHE_FILENAME
+ cache_path.write_text(json.dumps({"file.py": "abc123"}))
+
+ result = runner.invoke(
+ app,
+ ["delete-project", "--name", "platform", "--repo-path", str(tmp_path)],
+ )
+
+ assert result.exit_code == 0, result.output
+ assert not cache_path.exists()
+
+
+@patch("codebase_rag.cli.delete_project_embeddings")
+def test_delete_project_without_repo_path_leaves_unrelated_hash_caches(
+ mock_delete_embeddings: MagicMock,
+ mock_memgraph_connect: MagicMock,
+ tmp_path: Path,
+) -> None:
+ cache_path = tmp_path / cs.HASH_CACHE_FILENAME
+ cache_path.write_text(json.dumps({"file.py": "abc123"}))
+
+ result = runner.invoke(app, ["delete-project", "--name", "platform"])
+
+ assert result.exit_code == 0, result.output
+ assert cache_path.exists()
+
+
+@patch("codebase_rag.cli.delete_project_embeddings")
+def test_delete_project_does_not_wipe_other_projects(
+ mock_delete_embeddings: MagicMock,
+ mock_memgraph_connect: MagicMock,
+) -> None:
+ result = runner.invoke(app, ["delete-project", "--name", "platform"])
+
+ assert result.exit_code == 0, result.output
+ ingestor = _get_ingestor(mock_memgraph_connect)
+ ingestor.clean_database.assert_not_called()
+
+
+@patch("codebase_rag.cli.delete_project_embeddings")
+def test_delete_project_shows_success_message(
+ mock_delete_embeddings: MagicMock,
+ mock_memgraph_connect: MagicMock,
+) -> None:
+ result = runner.invoke(app, ["delete-project", "--name", "platform"])
+
+ assert result.exit_code == 0, result.output
+ stripped = _strip_ansi(result.output)
+ assert cs.CLI_MSG_PROJECT_DELETED.format(project_name="platform") in stripped
diff --git a/codebase_rag/tests/test_cli_repo_path_validation.py b/codebase_rag/tests/test_cli_repo_path_validation.py
new file mode 100644
index 000000000..f91a6ffa6
--- /dev/null
+++ b/codebase_rag/tests/test_cli_repo_path_validation.py
@@ -0,0 +1,105 @@
+from __future__ import annotations
+
+import re
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from codebase_rag import constants as cs
+from codebase_rag.cli import app
+
+runner = CliRunner()
+
+_ANSI = re.compile(r"\x1b\[[0-9;]*m")
+
+
+def _plain(output: str) -> str:
+ # (H) ANSI-stripped output with Rich soft-wrap newlines rejoined
+ return _ANSI.sub("", output).replace("\n", "")
+
+
+@pytest.fixture
+def mock_memgraph_connect() -> Generator[MagicMock, None, None]:
+ with (
+ patch("codebase_rag.cli.connect_memgraph") as mock_connect,
+ patch("codebase_rag.cli._maybe_start_stack"),
+ ):
+ mock_ingestor = MagicMock()
+ mock_connect.return_value.__enter__ = MagicMock(return_value=mock_ingestor)
+ mock_connect.return_value.__exit__ = MagicMock(return_value=False)
+ yield mock_connect
+
+
+class TestStartRepoPathValidation:
+ def test_nonexistent_path_exits_with_error(
+ self, mock_memgraph_connect: MagicMock, tmp_path: Path
+ ) -> None:
+ missing = tmp_path / "does_not_exist"
+ result = runner.invoke(app, ["start", "--clean", "--repo-path", str(missing)])
+
+ assert result.exit_code == 1, result.output
+ plain = _plain(result.output)
+ assert str(missing) in plain
+ assert "does not exist" in plain
+
+ def test_file_path_exits_with_error(
+ self, mock_memgraph_connect: MagicMock, tmp_path: Path
+ ) -> None:
+ file_path = tmp_path / "a_file.txt"
+ file_path.write_text("not a directory")
+ result = runner.invoke(app, ["start", "--clean", "--repo-path", str(file_path)])
+
+ assert result.exit_code == 1, result.output
+ plain = _plain(result.output)
+ assert str(file_path) in plain
+ assert "not a directory" in plain
+
+ def test_valid_non_git_dir_warns_but_proceeds(
+ self, mock_memgraph_connect: MagicMock, tmp_path: Path
+ ) -> None:
+ result = runner.invoke(app, ["start", "--clean", "--repo-path", str(tmp_path)])
+
+ assert result.exit_code == 0, result.output
+ plain = _plain(result.output)
+ assert "not a Git repository" in plain
+ assert str(tmp_path) in plain
+
+ def test_git_dir_does_not_warn(
+ self, mock_memgraph_connect: MagicMock, tmp_path: Path
+ ) -> None:
+ (tmp_path / cs.GIT_DIR_NAME).mkdir()
+ result = runner.invoke(app, ["start", "--clean", "--repo-path", str(tmp_path)])
+
+ assert result.exit_code == 0, result.output
+ assert "not a Git repository" not in result.output
+
+ def test_git_file_worktree_does_not_warn(
+ self, mock_memgraph_connect: MagicMock, tmp_path: Path
+ ) -> None:
+ # (H) worktrees and submodules use a .git file, not a directory
+ (tmp_path / cs.GIT_DIR_NAME).write_text("gitdir: /repo/.git/worktrees/wt\n")
+ result = runner.invoke(app, ["start", "--clean", "--repo-path", str(tmp_path)])
+
+ assert result.exit_code == 0, result.output
+ assert "not a Git repository" not in result.output
+
+
+class TestIndexRepoPathValidation:
+ def test_index_nonexistent_path_exits_with_error(self, tmp_path: Path) -> None:
+ missing = tmp_path / "nope"
+ result = runner.invoke(
+ app,
+ [
+ "index",
+ "--repo-path",
+ str(missing),
+ "-o",
+ str(tmp_path / "out"),
+ ],
+ )
+
+ assert result.exit_code == 1, result.output
+ assert "does not exist" in _plain(result.output)
diff --git a/codebase_rag/tests/test_cli_smoke.py b/codebase_rag/tests/test_cli_smoke.py
index 88b420e07..06a254bda 100644
--- a/codebase_rag/tests/test_cli_smoke.py
+++ b/codebase_rag/tests/test_cli_smoke.py
@@ -1,9 +1,15 @@
+import re
import subprocess
import sys
+from importlib.metadata import version as get_version
from pathlib import Path
import pytest
+from codebase_rag import constants as cs
+
+_ANSI_RE = re.compile(r"\x1b\[[0-9;]*m")
+
def test_help_command_works() -> None:
repo_root = Path(__file__).parent.parent.parent
@@ -15,14 +21,14 @@ def test_help_command_works() -> None:
capture_output=True,
text=True,
timeout=30,
+ env={**__import__("os").environ, "NO_COLOR": "1"},
)
assert result.returncode == 0, f"Help command failed with: {result.stderr}"
- assert "Usage:" in result.stdout or "usage:" in result.stdout.lower()
- assert "--help" in result.stdout
-
- assert result.stderr == "", f"Unexpected stderr: {result.stderr}"
+ plain_stdout = _ANSI_RE.sub("", result.stdout)
+ assert "Usage:" in plain_stdout or "usage:" in plain_stdout.lower()
+ assert "--help" in plain_stdout
def test_import_cli_module() -> None:
@@ -32,3 +38,28 @@ def test_import_cli_module() -> None:
assert hasattr(cli, "app"), "CLI module missing app attribute"
except ImportError as e:
pytest.fail(f"Failed to import cli module: {e}")
+
+
+def test_version_flag() -> None:
+ repo_root = Path(__file__).parent.parent.parent
+
+ for flag in ["--version", "-v"]:
+ result = subprocess.run(
+ [sys.executable, "-m", "codebase_rag.cli", flag],
+ check=False,
+ cwd=repo_root,
+ capture_output=True,
+ text=True,
+ timeout=30,
+ )
+
+ assert result.returncode == 0, (
+ f"{flag} exited with code {result.returncode}: {result.stderr}"
+ )
+ expected = cs.CLI_MSG_VERSION.format(
+ package=cs.PACKAGE_NAME, version=get_version(cs.PACKAGE_NAME)
+ )
+ assert result.stdout.strip() == expected, (
+ f"{flag} output did not match expected format: {repr(result.stdout)}"
+ )
+ assert result.stderr == "", f"Unexpected stderr for {flag}: {result.stderr}"
diff --git a/codebase_rag/tests/test_codebase_query.py b/codebase_rag/tests/test_codebase_query.py
index 3be753570..6c7f5a5bf 100644
--- a/codebase_rag/tests/test_codebase_query.py
+++ b/codebase_rag/tests/test_codebase_query.py
@@ -69,6 +69,22 @@ def test_uses_provided_console(
tool = create_query_tool(mock_ingestor, mock_cypher_gen, console=mock_console)
assert tool is not None
+ async def test_default_console_writes_to_stderr(
+ self,
+ mock_ingestor: MagicMock,
+ mock_cypher_gen: MagicMock,
+ capsys: pytest.CaptureFixture[str],
+ ) -> None:
+ mock_cypher_gen.generate = AsyncMock(return_value="MATCH (n) RETURN n")
+ mock_ingestor.fetch_all.return_value = [{"name": "example"}]
+
+ tool = create_query_tool(mock_ingestor, mock_cypher_gen, console=None)
+ await tool.function(natural_language_query="Find all functions")
+
+ captured = capsys.readouterr()
+ assert captured.out == ""
+ assert captured.err != ""
+
class TestQueryCodebaseKnowledgeGraph:
async def test_successful_query_returns_results(
@@ -145,6 +161,25 @@ async def test_database_error_handled(
assert result.results == []
assert "error" in result.summary.lower()
+ async def test_query_timeout_handled(
+ self,
+ mock_ingestor: MagicMock,
+ mock_cypher_gen: MagicMock,
+ mock_console: Console,
+ monkeypatch: pytest.MonkeyPatch,
+ ) -> None:
+ import time
+
+ from codebase_rag.config import settings
+
+ monkeypatch.setattr(settings, "QUERY_TIMEOUT_S", 0.05)
+ mock_ingestor.fetch_all.side_effect = lambda *a, **k: time.sleep(1.0)
+ tool = create_query_tool(mock_ingestor, mock_cypher_gen, console=mock_console)
+ result = await tool.function(natural_language_query="long running query")
+ assert result.results == []
+ assert "timeout" in result.summary.lower()
+ assert result.query_used == "MATCH (n) RETURN n"
+
class TestQueryResultFormatting:
async def test_result_contains_query_used(
diff --git a/codebase_rag/tests/test_conditional_alias_call.py b/codebase_rag/tests/test_conditional_alias_call.py
new file mode 100644
index 000000000..901d395c5
--- /dev/null
+++ b/codebase_rag/tests/test_conditional_alias_call.py
@@ -0,0 +1,87 @@
+# (H) L3 finding from the evals/ harness: CallProcessor._ingest_function_calls binds a
+# (H) local to a conditionally-selected bound method (resolve_builtin =
+# (H) resolver.resolve_builtin_call if is_js_ts else None) then calls it. The alias must
+# (H) be resolved through the non-None branch of the conditional to its real method.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+FILES = {
+ "pkg/__init__.py": "",
+ "pkg/helper.py": (
+ "class Helper:\n def do(self, value):\n return value\n"
+ ),
+ "pkg/worker.py": (
+ "from .helper import Helper\n\n\n"
+ "class Worker:\n"
+ " def __init__(self) -> None:\n"
+ " self._helper = Helper()\n\n"
+ " def run(self, value, flag):\n"
+ " helper = self._helper\n"
+ " fn = helper.do if flag else None\n"
+ " return fn(value)\n"
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestConditionalAliasCall:
+ def test_conditional_bound_method_alias_resolves(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.worker.Worker.run",
+ "proj.pkg.helper.Helper.do",
+ ) in calls, calls
diff --git a/codebase_rag/tests/test_config_validation.py b/codebase_rag/tests/test_config_validation.py
new file mode 100644
index 000000000..c17c51a26
--- /dev/null
+++ b/codebase_rag/tests/test_config_validation.py
@@ -0,0 +1,85 @@
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.config import ModelConfig, format_missing_api_key_errors
+
+
+class TestValidateApiKey:
+ def test_local_providers_skip_validation(self) -> None:
+ cfg = ModelConfig(provider=cs.Provider.OLLAMA, model_id="llama3")
+ cfg.validate_api_key()
+
+ def test_google_vertex_skips_validation(self) -> None:
+ cfg = ModelConfig(
+ provider=cs.Provider.GOOGLE,
+ model_id="gemini-pro",
+ provider_type=cs.GoogleProviderType.VERTEX,
+ )
+ cfg.validate_api_key()
+
+ def test_google_gla_requires_api_key(self) -> None:
+ cfg = ModelConfig(
+ provider=cs.Provider.GOOGLE,
+ model_id="gemini-pro",
+ provider_type=cs.GoogleProviderType.GLA,
+ )
+ with pytest.raises(ValueError, match="API Key Missing"):
+ cfg.validate_api_key()
+
+ @pytest.mark.parametrize(
+ "api_key_kwargs",
+ [
+ {},
+ {"api_key": ""},
+ {"api_key": " "},
+ {"api_key": cs.DEFAULT_API_KEY},
+ ],
+ )
+ def test_invalid_api_key_raises(self, api_key_kwargs: dict[str, str]) -> None:
+ cfg = ModelConfig(
+ provider=cs.Provider.OPENAI, model_id="gpt-4", **api_key_kwargs
+ )
+ with pytest.raises(ValueError, match="API Key Missing"):
+ cfg.validate_api_key()
+
+ def test_valid_api_key_passes(self) -> None:
+ cfg = ModelConfig(
+ provider=cs.Provider.OPENAI, model_id="gpt-4", api_key="sk-real-key-123"
+ )
+ cfg.validate_api_key()
+
+ def test_role_forwarded_to_error_message(self) -> None:
+ cfg = ModelConfig(provider=cs.Provider.OPENAI, model_id="gpt-4")
+ with pytest.raises(ValueError, match="cypher"):
+ cfg.validate_api_key(role="cypher")
+
+
+class TestFormatMissingApiKeyErrors:
+ def test_known_provider_openai(self) -> None:
+ msg = format_missing_api_key_errors(cs.Provider.OPENAI)
+ assert "OPENAI_API_KEY" in msg
+ assert "https://platform.openai.com/api-keys" in msg
+ assert "OpenAI" in msg
+
+ def test_known_provider_anthropic(self) -> None:
+ msg = format_missing_api_key_errors(cs.Provider.ANTHROPIC)
+ assert "ANTHROPIC_API_KEY" in msg
+ assert "Anthropic" in msg
+
+ def test_unknown_provider_generic_message(self) -> None:
+ msg = format_missing_api_key_errors("deepseek")
+ assert "DEEPSEEK_API_KEY" in msg
+ assert "Deepseek" in msg
+
+ def test_role_appears_in_message(self) -> None:
+ msg = format_missing_api_key_errors(cs.Provider.OPENAI, role="cypher")
+ assert "for cypher" in msg
+
+ def test_default_role_omits_role_from_message(self) -> None:
+ msg = format_missing_api_key_errors(cs.Provider.OPENAI)
+ assert "for model" not in msg
+
+ def test_case_insensitive_lookup(self) -> None:
+ msg = format_missing_api_key_errors("OpenAI")
+ assert "OPENAI_API_KEY" in msg
+ assert "OpenAI" in msg
diff --git a/codebase_rag/tests/test_constructor_call_resolution.py b/codebase_rag/tests/test_constructor_call_resolution.py
new file mode 100644
index 000000000..5fed79020
--- /dev/null
+++ b/codebase_rag/tests/test_constructor_call_resolution.py
@@ -0,0 +1,87 @@
+# (H) L3 finding from the evals/ harness: instantiating a class (X()) is a call to
+# (H) X.__init__ at runtime, but cgr resolved the call to the class and dropped it.
+# (H) A constructor call must produce a CALLS edge to the class's __init__ method.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+MODULE_SRC = """class Widget:
+ def __init__(self) -> None:
+ self.x = 1
+
+
+class Plain:
+ pass
+
+
+def build() -> Widget:
+ return Widget()
+
+
+def build_plain() -> Plain:
+ return Plain()
+"""
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "m.py").write_text(MODULE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestConstructorCallResolution:
+ def test_instantiation_calls_init(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.build", "proj.m.Widget.__init__") in calls, calls
+
+ def test_instantiation_without_init_is_not_dropped_to_class(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ # (H) Plain has no __init__; cgr must not emit a CALLS edge to the class node.
+ assert ("proj.m.build_plain", "proj.m.Plain") not in calls, calls
diff --git a/codebase_rag/tests/test_cpp_cross_file_methods.py b/codebase_rag/tests/test_cpp_cross_file_methods.py
new file mode 100644
index 000000000..dbc2662de
--- /dev/null
+++ b/codebase_rag/tests/test_cpp_cross_file_methods.py
@@ -0,0 +1,462 @@
+"""Tests for C++ cross-file out-of-class method resolution (issue #496).
+
+When a class is declared in a header (.h) and methods are implemented
+out-of-class in a source file (.cpp) using ``ClassName::method`` syntax,
+the Method nodes must link back to the correct Class node via
+DEFINES_METHOD edges -- not to a phantom class constructed from the
+.cpp module's qualified name.
+"""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag.constants import SEPARATOR_DOT
+from codebase_rag.tests.conftest import (
+ get_nodes,
+ get_relationships,
+ run_updater,
+)
+
+# ---------------------------------------------------------------------------
+# Helpers
+# ---------------------------------------------------------------------------
+
+
+def _get_method_qns(mock_ingestor: MagicMock) -> set[str]:
+ """Return all Method qualified names recorded in the ingestor."""
+ return {call[0][1]["qualified_name"] for call in get_nodes(mock_ingestor, "Method")}
+
+
+def _get_class_qns(mock_ingestor: MagicMock) -> set[str]:
+ """Return all Class qualified names recorded in the ingestor."""
+ return {call[0][1]["qualified_name"] for call in get_nodes(mock_ingestor, "Class")}
+
+
+def _get_defines_method_edges(
+ mock_ingestor: MagicMock,
+) -> list[tuple[str, str]]:
+ """Return ``(class_qn, method_qn)`` pairs from DEFINES_METHOD rels."""
+ edges: list[tuple[str, str]] = []
+ for rel in get_relationships(mock_ingestor, "DEFINES_METHOD"):
+ class_qn = rel.args[0][2]
+ method_qn = rel.args[2][2]
+ edges.append((class_qn, method_qn))
+ return edges
+
+
+def _method_names_for_class(mock_ingestor: MagicMock, class_name: str) -> set[str]:
+ """Method simple-names linked via DEFINES_METHOD to *class_name*."""
+ names: set[str] = set()
+ for class_qn, method_qn in _get_defines_method_edges(mock_ingestor):
+ parts = class_qn.split(SEPARATOR_DOT)
+ if class_name in parts:
+ names.add(method_qn.split(SEPARATOR_DOT)[-1])
+ return names
+
+
+# ---------------------------------------------------------------------------
+# Fixtures
+# ---------------------------------------------------------------------------
+
+
+@pytest.fixture
+def cpp_cross_file_project(temp_repo: Path) -> Path:
+ project = temp_repo / "cpp_cross_file"
+ project.mkdir()
+ return project
+
+
+# ---------------------------------------------------------------------------
+# Test: basic header + source cross-file methods
+# ---------------------------------------------------------------------------
+
+
+def test_header_source_method_resolution(
+ cpp_cross_file_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ """Class in .h, implementations in .cpp -- methods must link to .h class."""
+ include = cpp_cross_file_project / "include"
+ include.mkdir()
+ src = cpp_cross_file_project / "src"
+ src.mkdir()
+
+ (include / "Calculator.h").write_text(
+ encoding="utf-8",
+ data="""\
+#pragma once
+
+class Calculator {
+public:
+ int add(int a, int b);
+ int subtract(int a, int b);
+ double divide(int a, int b);
+};
+""",
+ )
+
+ (src / "Calculator.cpp").write_text(
+ encoding="utf-8",
+ data="""\
+#include "Calculator.h"
+
+int Calculator::add(int a, int b) {
+ return a + b;
+}
+
+int Calculator::subtract(int a, int b) {
+ return a - b;
+}
+
+double Calculator::divide(int a, int b) {
+ if (b == 0) return 0;
+ return static_cast(a) / b;
+}
+""",
+ )
+
+ run_updater(cpp_cross_file_project, mock_ingestor)
+
+ # The class should exist in the header module.
+ class_qns = _get_class_qns(mock_ingestor)
+ header_class = [qn for qn in class_qns if "include" in qn and "Calculator" in qn]
+ assert header_class, (
+ f"Expected a Calculator class in include/, got classes: {class_qns}"
+ )
+
+ # All three out-of-class methods should have DEFINES_METHOD edges
+ # pointing to the *header* class, not to a phantom class in src/.
+ edges = _get_defines_method_edges(mock_ingestor)
+ header_class_qn = header_class[0]
+ methods_linked_to_header = {
+ mq.split(SEPARATOR_DOT)[-1] for cq, mq in edges if cq == header_class_qn
+ }
+
+ assert "add" in methods_linked_to_header, (
+ f"'add' not linked to header class. Edges: {edges}"
+ )
+ assert "subtract" in methods_linked_to_header, (
+ f"'subtract' not linked to header class. Edges: {edges}"
+ )
+ assert "divide" in methods_linked_to_header, (
+ f"'divide' not linked to header class. Edges: {edges}"
+ )
+
+ # There should be NO orphan Method nodes (methods whose container_qn
+ # uses the .cpp module instead of the .h module).
+ method_qns = _get_method_qns(mock_ingestor)
+ orphan_methods = {
+ qn
+ for qn in method_qns
+ if "src.Calculator" in qn and "Calculator.Calculator" in qn
+ }
+ assert not orphan_methods, (
+ f"Found orphan methods with .cpp module QN: {orphan_methods}"
+ )
+
+
+# ---------------------------------------------------------------------------
+# Test: multiple source files implementing one header class
+# ---------------------------------------------------------------------------
+
+
+def test_multiple_source_files_one_class(
+ cpp_cross_file_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ """Two .cpp files implement methods of one class declared in .h."""
+ include = cpp_cross_file_project / "include"
+ include.mkdir()
+ src = cpp_cross_file_project / "src"
+ src.mkdir()
+
+ (include / "Engine.h").write_text(
+ encoding="utf-8",
+ data="""\
+#pragma once
+
+class Engine {
+public:
+ void start();
+ void stop();
+ void accelerate(int speed);
+ void brake();
+};
+""",
+ )
+
+ (src / "engine_control.cpp").write_text(
+ encoding="utf-8",
+ data="""\
+#include "Engine.h"
+
+void Engine::start() { /* ... */ }
+void Engine::stop() { /* ... */ }
+""",
+ )
+
+ (src / "engine_movement.cpp").write_text(
+ encoding="utf-8",
+ data="""\
+#include "Engine.h"
+
+void Engine::accelerate(int speed) { /* ... */ }
+void Engine::brake() { /* ... */ }
+""",
+ )
+
+ run_updater(cpp_cross_file_project, mock_ingestor)
+
+ class_qns = _get_class_qns(mock_ingestor)
+ header_classes = [qn for qn in class_qns if "include" in qn and "Engine" in qn]
+ assert header_classes, f"Expected Engine class in include/, got: {class_qns}"
+ header_class_qn = header_classes[0]
+
+ edges = _get_defines_method_edges(mock_ingestor)
+ methods_linked = {
+ mq.split(SEPARATOR_DOT)[-1] for cq, mq in edges if cq == header_class_qn
+ }
+
+ for method_name in ("start", "stop", "accelerate", "brake"):
+ assert method_name in methods_linked, (
+ f"'{method_name}' not linked to header Engine class. "
+ f"Linked methods: {methods_linked}"
+ )
+
+
+# ---------------------------------------------------------------------------
+# Test: constructor and destructor out-of-class across files
+# ---------------------------------------------------------------------------
+
+
+def test_cross_file_constructor_destructor(
+ cpp_cross_file_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ """Constructors and destructors implemented in .cpp link to .h class."""
+ include = cpp_cross_file_project / "include"
+ include.mkdir()
+ src = cpp_cross_file_project / "src"
+ src.mkdir()
+
+ (include / "Resource.h").write_text(
+ encoding="utf-8",
+ data="""\
+#pragma once
+
+class Resource {
+public:
+ Resource();
+ Resource(int size);
+ ~Resource();
+ void reset();
+private:
+ int* data_;
+};
+""",
+ )
+
+ (src / "Resource.cpp").write_text(
+ encoding="utf-8",
+ data="""\
+#include "Resource.h"
+
+Resource::Resource() : data_(nullptr) {}
+
+Resource::Resource(int size) {
+ data_ = new int[size];
+}
+
+Resource::~Resource() {
+ delete[] data_;
+}
+
+void Resource::reset() {
+ delete[] data_;
+ data_ = nullptr;
+}
+""",
+ )
+
+ run_updater(cpp_cross_file_project, mock_ingestor)
+
+ class_qns = _get_class_qns(mock_ingestor)
+ header_classes = [qn for qn in class_qns if "include" in qn and "Resource" in qn]
+ assert header_classes, f"Expected Resource class in include/, got: {class_qns}"
+ header_class_qn = header_classes[0]
+
+ edges = _get_defines_method_edges(mock_ingestor)
+ methods_linked = {
+ mq.split(SEPARATOR_DOT)[-1] for cq, mq in edges if cq == header_class_qn
+ }
+
+ assert "Resource" in methods_linked, (
+ f"Constructor not linked to header class. Methods: {methods_linked}"
+ )
+ assert "~Resource" in methods_linked, (
+ f"Destructor not linked to header class. Methods: {methods_linked}"
+ )
+ assert "reset" in methods_linked, (
+ f"'reset' not linked to header class. Methods: {methods_linked}"
+ )
+
+
+# ---------------------------------------------------------------------------
+# Test: nested namespace cross-file methods
+# ---------------------------------------------------------------------------
+
+
+def test_nested_namespace_cross_file(
+ cpp_cross_file_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ """Class inside nested namespaces, methods implemented in separate .cpp."""
+ include = cpp_cross_file_project / "include"
+ include.mkdir()
+ src = cpp_cross_file_project / "src"
+ src.mkdir()
+
+ (include / "Logger.h").write_text(
+ encoding="utf-8",
+ data="""\
+#pragma once
+
+namespace app {
+namespace logging {
+
+class Logger {
+public:
+ void info(const char* msg);
+ void error(const char* msg);
+};
+
+} // namespace logging
+} // namespace app
+""",
+ )
+
+ (src / "Logger.cpp").write_text(
+ encoding="utf-8",
+ data="""\
+#include "Logger.h"
+
+namespace app {
+namespace logging {
+
+void Logger::info(const char* msg) { /* ... */ }
+void Logger::error(const char* msg) { /* ... */ }
+
+} // namespace logging
+} // namespace app
+""",
+ )
+
+ run_updater(cpp_cross_file_project, mock_ingestor)
+
+ class_qns = _get_class_qns(mock_ingestor)
+ header_classes = [qn for qn in class_qns if "include" in qn and "Logger" in qn]
+ assert header_classes, f"Expected Logger class in include/, got: {class_qns}"
+ header_class_qn = header_classes[0]
+
+ edges = _get_defines_method_edges(mock_ingestor)
+ methods_linked = {
+ mq.split(SEPARATOR_DOT)[-1] for cq, mq in edges if cq == header_class_qn
+ }
+
+ assert "info" in methods_linked, (
+ f"'info' not linked to header Logger. Methods: {methods_linked}"
+ )
+ assert "error" in methods_linked, (
+ f"'error' not linked to header Logger. Methods: {methods_linked}"
+ )
+
+
+# ---------------------------------------------------------------------------
+# Test: no orphan methods remain (aggregate check)
+# ---------------------------------------------------------------------------
+
+
+def test_no_orphan_methods_across_files(
+ cpp_cross_file_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ """Every Method node must have at least one incoming DEFINES_METHOD edge."""
+ include = cpp_cross_file_project / "include"
+ include.mkdir()
+ src = cpp_cross_file_project / "src"
+ src.mkdir()
+
+ (include / "Widget.h").write_text(
+ encoding="utf-8",
+ data="""\
+#pragma once
+
+class Widget {
+public:
+ void draw();
+ void resize(int w, int h);
+ void hide();
+};
+""",
+ )
+
+ (src / "Widget.cpp").write_text(
+ encoding="utf-8",
+ data="""\
+#include "Widget.h"
+
+void Widget::draw() { /* ... */ }
+void Widget::resize(int w, int h) { /* ... */ }
+void Widget::hide() { /* ... */ }
+""",
+ )
+
+ run_updater(cpp_cross_file_project, mock_ingestor)
+
+ method_qns = _get_method_qns(mock_ingestor)
+ edges = _get_defines_method_edges(mock_ingestor)
+ methods_with_edges = {mq for _, mq in edges}
+
+ orphans = method_qns - methods_with_edges
+ # Filter to only methods belonging to Widget (other methods from inline
+ # definitions always have edges).
+ widget_orphans = {qn for qn in orphans if "Widget" in qn}
+ assert not widget_orphans, (
+ f"Found orphan Widget Method nodes with no DEFINES_METHOD edge: "
+ f"{widget_orphans}"
+ )
+
+
+# ---------------------------------------------------------------------------
+# Test: same-file out-of-class still works (regression)
+# ---------------------------------------------------------------------------
+
+
+def test_same_file_out_of_class_still_works(
+ cpp_cross_file_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ """When class and implementations are in the same .cpp, nothing breaks."""
+ (cpp_cross_file_project / "single.cpp").write_text(
+ encoding="utf-8",
+ data="""\
+class Foo {
+public:
+ void bar();
+ int baz(int x);
+};
+
+void Foo::bar() { /* ... */ }
+int Foo::baz(int x) { return x; }
+""",
+ )
+
+ run_updater(cpp_cross_file_project, mock_ingestor)
+
+ method_names = _method_names_for_class(mock_ingestor, "Foo")
+ assert "bar" in method_names, f"Expected 'bar', got: {method_names}"
+ assert "baz" in method_names, f"Expected 'baz', got: {method_names}"
diff --git a/codebase_rag/tests/test_cpp_cross_file_singleton.py b/codebase_rag/tests/test_cpp_cross_file_singleton.py
index 403d16c4b..023d82226 100644
--- a/codebase_rag/tests/test_cpp_cross_file_singleton.py
+++ b/codebase_rag/tests/test_cpp_cross_file_singleton.py
@@ -147,15 +147,21 @@ def test_cpp_singleton_pattern_cross_file_calls(
found_calls.add((caller_short, callee_short))
+ # (H) Calls are attributed to the enclosing method/function, not the file:
+ # the singleton calls live inside SceneController's methods and
+ # Application.start(), so those are the callers (not the module nodes).
+ sc = "controllers.SceneController.SceneController"
expected_calls = [
- ("controllers.SceneController", "storage.Storage.Storage.getInstance"),
- ("controllers.SceneController", "storage.Storage.Storage.clearAll"),
- ("controllers.SceneController", "storage.Storage.Storage.save"),
- ("controllers.SceneController", "storage.Storage.Storage.load"),
- ("main", "controllers.SceneController.SceneController.loadMenuScene"),
- ("main", "controllers.SceneController.SceneController.loadGameScene"),
- ("main", "storage.Storage.Storage.getInstance"),
- ("main", "storage.Storage.Storage.load"),
+ (f"{sc}.loadMenuScene", "storage.Storage.Storage.getInstance"),
+ (f"{sc}.loadMenuScene", "storage.Storage.Storage.clearAll"),
+ (f"{sc}.loadMenuScene", "storage.Storage.Storage.save"),
+ (f"{sc}.loadMenuScene", "storage.Storage.Storage.load"),
+ (f"{sc}.loadGameScene", "storage.Storage.Storage.getInstance"),
+ (f"{sc}.loadGameScene", "storage.Storage.Storage.save"),
+ ("main.Application.start", f"{sc}.loadMenuScene"),
+ ("main.Application.start", f"{sc}.loadGameScene"),
+ ("main.Application.start", "storage.Storage.Storage.getInstance"),
+ ("main.Application.start", "storage.Storage.Storage.load"),
("main.main", "main.Application.start"),
]
diff --git a/codebase_rag/tests/test_cpp_crosslang_qn_collision.py b/codebase_rag/tests/test_cpp_crosslang_qn_collision.py
new file mode 100644
index 000000000..6935b5ece
--- /dev/null
+++ b/codebase_rag/tests/test_cpp_crosslang_qn_collision.py
@@ -0,0 +1,59 @@
+# (H) Regression: a C++ out-of-class method (Widget::render) must not bind to a
+# (H) same-named class in another language (Python's Widget), which would give the
+# (H) two methods an identical qualified_name and collapse them under the graph's
+# (H) qualified_name unique constraint (silently dropping the Python method).
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.constants import KEY_PATH, KEY_QUALIFIED_NAME, NodeLabel
+from codebase_rag.tests.conftest import create_and_run_updater, get_nodes
+
+
+def _make_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "crosslang"
+ (project_path / "app").mkdir(parents=True)
+ (project_path / "lib").mkdir(parents=True)
+ (project_path / "app" / "widget.py").write_text(
+ encoding="utf-8",
+ data="class Widget:\n def render(self):\n return 1\n",
+ )
+ # (H) Out-of-class C++ method with no C++ Widget class anywhere in the repo:
+ # (H) the only Widget class cgr knows is the Python one.
+ (project_path / "lib" / "widget.cpp").write_text(
+ encoding="utf-8",
+ data="int Widget::render() {\n return 2;\n}\n",
+ )
+ return project_path
+
+
+def _methods_named(mock_ingestor: MagicMock, name: str) -> list[tuple[str, str]]:
+ out: list[tuple[str, str]] = []
+ for node in get_nodes(mock_ingestor, NodeLabel.METHOD):
+ props = node[0][1]
+ qn = str(props.get(KEY_QUALIFIED_NAME))
+ if qn.rsplit(".", 1)[-1] == name:
+ out.append((qn, str(props.get(KEY_PATH))))
+ return out
+
+
+def test_cpp_method_does_not_steal_python_method_qn(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = _make_project(temp_repo)
+ create_and_run_updater(project, mock_ingestor, skip_if_missing="cpp")
+
+ renders = _methods_named(mock_ingestor, "render")
+ qns = [qn for qn, _ in renders]
+ # (H) The Python and C++ render methods must each have a distinct qn; no two
+ # (H) render method nodes may collide on the same qualified_name.
+ assert len(qns) == len(set(qns)), f"colliding render qns: {renders}"
+
+ py_qns = {qn for qn, path in renders if path.endswith("widget.py")}
+ cpp_qns = {qn for qn, path in renders if path.endswith("widget.cpp")}
+ assert py_qns, f"python Widget.render missing: {renders}"
+ assert cpp_qns, f"cpp Widget::render missing: {renders}"
+ assert py_qns.isdisjoint(cpp_qns), (
+ f"cpp method bound to python class qn: py={py_qns} cpp={cpp_qns}"
+ )
diff --git a/codebase_rag/tests/test_cpp_frontend_calls.py b/codebase_rag/tests/test_cpp_frontend_calls.py
new file mode 100644
index 000000000..5b6737cd4
--- /dev/null
+++ b/codebase_rag/tests/test_cpp_frontend_calls.py
@@ -0,0 +1,85 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag.parsers.cpp_frontend import cpp_frontend_available, run_cpp_frontend
+
+pytestmark = pytest.mark.skipif(
+ not cpp_frontend_available(),
+ reason="libclang not available",
+)
+
+# (H) An out-of-line method calling a free function. tree-sitter's cgr path
+# (H) historically dangled the caller qn (PR #47); libclang resolves the call
+# (H) target via cursor.referenced with no name heuristic, and the frontend
+# (H) anchors the caller to the method node itself.
+_HEADER = """
+namespace m {
+
+class Calc {
+public:
+ int add(int a, int b);
+};
+
+int helper(int x);
+
+} // namespace m
+"""
+
+_SRC = """
+#include "calc.h"
+namespace m {
+int helper(int x) { return x + 1; }
+int Calc::add(int a, int b) { return helper(a) + b; }
+}
+"""
+
+
+def _write(root: Path) -> None:
+ root.mkdir()
+ (root / "calc.h").write_text(_HEADER, encoding="utf-8")
+ (root / "calc.cpp").write_text(_SRC, encoding="utf-8")
+ (root / "compile_commands.json").write_text(
+ json.dumps(
+ [
+ {
+ "directory": str(root),
+ "arguments": ["c++", "-std=c++17", str(root / "calc.cpp")],
+ "file": str(root / "calc.cpp"),
+ }
+ ]
+ ),
+ encoding="utf-8",
+ )
+
+
+def _calls(ingestor: MagicMock) -> list[tuple[str, str, str, str]]:
+ out = []
+ for c in ingestor.ensure_relationship_batch.call_args_list:
+ if c.args[1] == "CALLS":
+ (from_label, _, from_qn) = c.args[0]
+ (to_label, _, to_qn) = c.args[2]
+ out.append((from_label, from_qn, to_label, to_qn))
+ return out
+
+
+def test_method_calls_free_function(temp_repo: Path) -> None:
+ root = temp_repo / "callsproj"
+ _write(root)
+
+ ingestor = MagicMock()
+ run_cpp_frontend(ingestor, root, root.name, root)
+
+ calls = _calls(ingestor)
+ # (H) The caller is the METHOD node (not a dangling free-function/module qn).
+ assert any(
+ from_label == "Method"
+ and from_qn.endswith(".m.Calc.add")
+ and to_label == "Function"
+ and to_qn.endswith(".m.helper")
+ for from_label, from_qn, to_label, to_qn in calls
+ ), f"expected Calc.add CALLS helper, got {calls}"
diff --git a/codebase_rag/tests/test_cpp_frontend_qn_parity.py b/codebase_rag/tests/test_cpp_frontend_qn_parity.py
new file mode 100644
index 000000000..1b0d301e9
--- /dev/null
+++ b/codebase_rag/tests/test_cpp_frontend_qn_parity.py
@@ -0,0 +1,218 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag.parsers.cpp_frontend import cpp_frontend_available, run_cpp_frontend
+from codebase_rag.tests.conftest import get_nodes, get_qualified_names, run_updater
+
+pytestmark = pytest.mark.skipif(
+ not cpp_frontend_available(),
+ reason="libclang not available",
+)
+
+# (H) A macro-free C++ corpus: a namespaced class declared in a header with
+# (H) in-class declarations + one inline method, its out-of-line definitions in
+# (H) the .cpp, a free-function prototype in the header, and free-function
+# (H) definitions in the .cpp. Macro-free so the tree-sitter path parses it
+# (H) correctly and its qualified names are the ground truth the libclang
+# (H) frontend must reproduce exactly (the issue #46 acceptance test).
+HEADER = """
+namespace geo {
+
+class Shape {
+public:
+ Shape(double x);
+ virtual ~Shape();
+ double area() const;
+ virtual void describe();
+ int inline_helper() { return 7; }
+};
+
+int free_proto(int n);
+
+} // namespace geo
+"""
+
+SRC = """
+#include "geometry.h"
+
+namespace geo {
+
+Shape::Shape(double x) {}
+Shape::~Shape() {}
+double Shape::area() const { return 1.0; }
+void Shape::describe() {}
+
+int free_proto(int n) { return n + 1; }
+
+int only_in_cpp(int a) { return a; }
+
+} // namespace geo
+"""
+
+_LABELS = ("Class", "Function", "Method")
+
+
+def _write_project(root: Path) -> None:
+ root.mkdir()
+ (root / "geometry.h").write_text(HEADER, encoding="utf-8")
+ (root / "geometry.cpp").write_text(SRC, encoding="utf-8")
+ compile_commands = [
+ {
+ "directory": str(root),
+ "arguments": ["c++", "-std=c++17", str(root / "geometry.cpp")],
+ "file": str(root / "geometry.cpp"),
+ }
+ ]
+ (root / "compile_commands.json").write_text(
+ json.dumps(compile_commands), encoding="utf-8"
+ )
+
+
+def _qns_by_label(ingestor: MagicMock) -> dict[str, set[str]]:
+ return {label: get_qualified_names(get_nodes(ingestor, label)) for label in _LABELS}
+
+
+def test_frontend_qns_match_tree_sitter(temp_repo: Path) -> None:
+ root = temp_repo / "geomproj"
+ _write_project(root)
+
+ ts_ingestor = MagicMock()
+ run_updater(root, ts_ingestor)
+ ts_qns = _qns_by_label(ts_ingestor)
+
+ fe_ingestor = MagicMock()
+ run_cpp_frontend(fe_ingestor, root, root.name, root)
+ fe_qns = _qns_by_label(fe_ingestor)
+
+ assert fe_qns == ts_qns, (
+ f"frontend/tree-sitter qn mismatch:\n"
+ f" frontend only: { {k: fe_qns[k] - ts_qns[k] for k in _LABELS} }\n"
+ f" tree-sitter only: { {k: ts_qns[k] - fe_qns[k] for k in _LABELS} }"
+ )
+
+
+def _write_cpp_project(root: Path, header_name: str, header: str, src: str) -> None:
+ root.mkdir()
+ cpp_name = f"{Path(header_name).stem}.cpp"
+ (root / header_name).write_text(header, encoding="utf-8")
+ (root / cpp_name).write_text(src, encoding="utf-8")
+ compile_commands = [
+ {
+ "directory": str(root),
+ "arguments": ["c++", "-std=c++17", str(root / cpp_name)],
+ "file": str(root / cpp_name),
+ }
+ ]
+ (root / "compile_commands.json").write_text(
+ json.dumps(compile_commands), encoding="utf-8"
+ )
+
+
+# (H) A macro that tree-sitter cannot expand: `struct WIDGET_API Widget` is
+# (H) mis-parsed (WIDGET_API is read as the type), so cgr loses the `Widget`
+# (H) class entirely. libclang expands the macro and recovers it with its true
+# (H) multi-line span. This is the whole reason the frontend exists.
+_MACRO_HEADER = """
+#define WIDGET_API
+
+namespace ui {
+
+struct WIDGET_API Widget {
+ int handle;
+ void show();
+ void hide();
+};
+
+} // namespace ui
+"""
+
+_MACRO_SRC = """
+#include "widget.h"
+namespace ui {
+void Widget::show() {}
+void Widget::hide() {}
+}
+"""
+
+
+def test_frontend_recovers_macro_mangled_class(temp_repo: Path) -> None:
+ root = temp_repo / "macroproj"
+ _write_cpp_project(root, "widget.h", _MACRO_HEADER, _MACRO_SRC)
+
+ ts_ingestor = MagicMock()
+ run_updater(root, ts_ingestor)
+ ts_classes = get_qualified_names(get_nodes(ts_ingestor, "Class"))
+
+ fe_ingestor = MagicMock()
+ run_cpp_frontend(fe_ingestor, root, root.name, root)
+ fe_class_nodes = get_nodes(fe_ingestor, "Class")
+ fe_classes = get_qualified_names(fe_class_nodes)
+
+ # (H) tree-sitter loses Widget to the macro; the frontend recovers it.
+ assert not any(q.endswith(".ui.Widget") for q in ts_classes), (
+ f"expected tree-sitter to mis-parse Widget, got {ts_classes}"
+ )
+ assert any(q.endswith(".ui.Widget") for q in fe_classes), (
+ f"frontend did not recover Widget: {fe_classes}"
+ )
+
+ widget = next(
+ c[0][1] for c in fe_class_nodes if c[0][1]["qualified_name"].endswith(".Widget")
+ )
+ assert widget["end_line"] > widget["start_line"], (
+ f"expected a real multi-line span for Widget, got {widget}"
+ )
+
+
+_INHERIT_HEADER = """
+namespace geo {
+
+class Base {
+public:
+ virtual void run();
+};
+
+class Derived : public Base {
+public:
+ void run();
+ Derived operator+(const Derived& o) const;
+};
+
+} // namespace geo
+"""
+
+_INHERIT_SRC = """
+#include "shapes.h"
+namespace geo {
+void Base::run() {}
+void Derived::run() {}
+Derived Derived::operator+(const Derived& o) const { return *this; }
+}
+"""
+
+
+def test_frontend_emits_inheritance_and_operator(temp_repo: Path) -> None:
+ root = temp_repo / "shapesproj"
+ _write_cpp_project(root, "shapes.h", _INHERIT_HEADER, _INHERIT_SRC)
+
+ fe_ingestor = MagicMock()
+ run_cpp_frontend(fe_ingestor, root, root.name, root)
+
+ methods = get_qualified_names(get_nodes(fe_ingestor, "Method"))
+ assert any(q.endswith(".geo.Derived.operator_plus") for q in methods), (
+ f"operator+ not converted: {sorted(methods)}"
+ )
+
+ inherits = [
+ (c.args[0][2], c.args[2][2])
+ for c in fe_ingestor.ensure_relationship_batch.call_args_list
+ if c.args[1] == "INHERITS"
+ ]
+ assert any(
+ src.endswith(".geo.Derived") and dst.endswith(".Base") for src, dst in inherits
+ ), f"expected Derived INHERITS Base, got {inherits}"
diff --git a/codebase_rag/tests/test_cpp_frontend_types.py b/codebase_rag/tests/test_cpp_frontend_types.py
new file mode 100644
index 000000000..803448ef4
--- /dev/null
+++ b/codebase_rag/tests/test_cpp_frontend_types.py
@@ -0,0 +1,84 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag.parsers.cpp_frontend import cpp_frontend_available, run_cpp_frontend
+from codebase_rag.tests.conftest import get_nodes, get_qualified_names
+
+pytestmark = pytest.mark.skipif(
+ not cpp_frontend_available(),
+ reason="libclang not available",
+)
+
+# (H) C++ type aliases: namespace-scoped `using`/`typedef` and a class-scoped
+# (H) member alias. The tree-sitter path emits no Type nodes for these, so the
+# (H) frontend adds them (mirroring how Go/Rust type decls become Type nodes).
+_HEADER = """
+namespace n {
+
+using Meters = double;
+typedef int Count;
+
+class Box {
+public:
+ using Handle = int;
+};
+
+} // namespace n
+"""
+
+_SRC = '#include "types.h"\n'
+
+
+def _write(root: Path) -> None:
+ root.mkdir()
+ (root / "types.h").write_text(_HEADER, encoding="utf-8")
+ (root / "types.cpp").write_text(_SRC, encoding="utf-8")
+ (root / "compile_commands.json").write_text(
+ json.dumps(
+ [
+ {
+ "directory": str(root),
+ "arguments": ["c++", "-std=c++17", str(root / "types.cpp")],
+ "file": str(root / "types.cpp"),
+ }
+ ]
+ ),
+ encoding="utf-8",
+ )
+
+
+def test_frontend_emits_type_aliases(temp_repo: Path) -> None:
+ root = temp_repo / "typesproj"
+ _write(root)
+
+ ingestor = MagicMock()
+ run_cpp_frontend(ingestor, root, root.name, root)
+
+ types = get_qualified_names(get_nodes(ingestor, "Type"))
+ assert any(q.endswith(".n.Meters") for q in types), f"missing using alias: {types}"
+ assert any(q.endswith(".n.Count") for q in types), f"missing typedef: {types}"
+ assert any(q.endswith(".n.Box.Handle") for q in types), (
+ f"missing class-scoped alias: {types}"
+ )
+
+ defines = [
+ (c.args[0][0], c.args[0][2], c.args[2][2])
+ for c in ingestor.ensure_relationship_batch.call_args_list
+ if c.args[1] == "DEFINES"
+ ]
+ # (H) namespace-scoped alias defined by its Module; member alias by its Class.
+ assert any(
+ src_label == "Module" and child.endswith(".n.Meters")
+ for src_label, _, child in defines
+ ), f"Module should DEFINE Meters: {defines}"
+ assert any(
+ src_label == "Class"
+ and src_qn.endswith(".n.Box")
+ and child.endswith(".n.Box.Handle")
+ for src_label, src_qn, child in defines
+ ), f"Box should DEFINE Handle: {defines}"
diff --git a/codebase_rag/tests/test_cpp_frontend_wiring.py b/codebase_rag/tests/test_cpp_frontend_wiring.py
new file mode 100644
index 000000000..f2e167dbe
--- /dev/null
+++ b/codebase_rag/tests/test_cpp_frontend_wiring.py
@@ -0,0 +1,101 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag import graph_updater as gu
+from codebase_rag.parsers.cpp_frontend import cpp_frontend_available
+from codebase_rag.tests.conftest import get_nodes, get_qualified_names, run_updater
+
+pytestmark = pytest.mark.skipif(
+ not cpp_frontend_available(),
+ reason="libclang not available",
+)
+
+# (H) `struct WIDGET_API Widget` is a macro tree-sitter cannot expand: it loses
+# (H) the Widget class. The libclang frontend recovers it. The wiring decides
+# (H) which path runs, gated on CPP_FRONTEND + a discoverable compile_commands.
+_HEADER = """
+#define WIDGET_API
+
+namespace ui {
+
+struct WIDGET_API Widget {
+ int handle;
+ void show();
+};
+
+} // namespace ui
+"""
+
+_SRC = """
+#include "widget.h"
+namespace ui {
+void Widget::show() {}
+}
+"""
+
+
+def _write_project(root: Path) -> None:
+ root.mkdir()
+ (root / "widget.h").write_text(_HEADER, encoding="utf-8")
+ (root / "widget.cpp").write_text(_SRC, encoding="utf-8")
+ (root / "compile_commands.json").write_text(
+ json.dumps(
+ [
+ {
+ "directory": str(root),
+ "arguments": ["c++", "-std=c++17", str(root / "widget.cpp")],
+ "file": str(root / "widget.cpp"),
+ }
+ ]
+ ),
+ encoding="utf-8",
+ )
+
+
+def test_default_treesitter_does_not_recover_macro_class(temp_repo: Path) -> None:
+ root = temp_repo / "defaultproj"
+ _write_project(root)
+
+ ingestor = MagicMock()
+ run_updater(root, ingestor)
+ classes = get_qualified_names(get_nodes(ingestor, "Class"))
+
+ # (H) No regression: with the default flag, indexing is the tree-sitter path,
+ # (H) which mis-parses the macro and never produces ui.Widget.
+ assert not any(q.endswith(".ui.Widget") for q in classes), (
+ f"default path should not engage the frontend: {classes}"
+ )
+
+
+def test_libclang_frontend_recovers_macro_class(
+ temp_repo: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ root = temp_repo / "libclangproj"
+ _write_project(root)
+
+ monkeypatch.setattr(gu.settings, "CPP_FRONTEND", cs.CppFrontend.LIBCLANG)
+
+ ingestor = MagicMock()
+ run_updater(root, ingestor)
+
+ classes = get_qualified_names(get_nodes(ingestor, "Class"))
+ methods = get_qualified_names(get_nodes(ingestor, "Method"))
+
+ # (H) The frontend recovers the real class and binds the out-of-line method.
+ assert any(q.endswith(".ui.Widget") for q in classes), (
+ f"frontend did not recover Widget: {classes}"
+ )
+ assert any(q.endswith(".ui.Widget.show") for q in methods), (
+ f"frontend did not bind Widget::show: {methods}"
+ )
+ # (H) The covered file was NOT also processed by tree-sitter (no double-parse
+ # (H) producing the macro-mangled class).
+ assert not any(q.endswith(".ui.WIDGET_API") for q in classes), (
+ f"tree-sitter should have skipped the covered file: {classes}"
+ )
diff --git a/codebase_rag/tests/test_cpp_oracle.py b/codebase_rag/tests/test_cpp_oracle.py
new file mode 100644
index 000000000..bfed9aac5
--- /dev/null
+++ b/codebase_rag/tests/test_cpp_oracle.py
@@ -0,0 +1,215 @@
+# (H) Covers the C++ structure oracle (evals/oracles/cpp_oracle.py): a libclang
+# (H) oracle driven by a compile_commands.json resolves #includes and expands
+# (H) macros to the true translation-unit AST, which tree-sitter cannot do. cgr's
+# (H) C++ nodes, containment edges, and spans are graded against it on
+# (H) (kind, file, start_line). The sample exercises a header-declared class
+# (H) (resolved via an -I include path), a macro-typed method, out-of-class method
+# (H) definitions, a constructor, an inline method, a struct, and a free function.
+from __future__ import annotations
+
+import json
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_cpp_graph, restrict_to_files
+from evals.oracles import cpp_available, run_cpp_oracle
+from evals.score import (
+ score_edge_types,
+ score_name_edge_types,
+ score_node_kinds,
+ score_span,
+)
+from evals.types_defs import (
+ DefNode,
+ EdgeKey,
+ GraphData,
+ NameEdge,
+ NodeKey,
+ ScoreRow,
+)
+
+SHAPE_H = """\
+#pragma once
+#define AREA_T double
+
+struct Point {
+ int x;
+ int y;
+};
+
+class Shape {
+public:
+ Shape(int id);
+ AREA_T area() const;
+ void scale(
+ double factor
+ );
+ int inline_id() const { return id_; }
+private:
+ int id_;
+};
+"""
+
+SHAPE_CPP = """\
+#include "shape.h"
+
+Shape::Shape(int id) : id_(id) {
+}
+
+AREA_T Shape::area() const {
+ return 1.0;
+}
+
+void Shape::scale(double factor) {
+ id_ = static_cast(factor);
+}
+
+int helper(int n) {
+ return n * 2;
+}
+"""
+
+
+def _require_cpp() -> None:
+ if not cpp_available():
+ pytest.skip("libclang not available")
+ if cs.SupportedLanguage.CPP not in load_parsers()[0]:
+ pytest.skip("cpp parser not available")
+
+
+def _aggregate(rows: list[ScoreRow]) -> ScoreRow | None:
+ return next((r for r in rows if r["label"] == ec.AGGREGATE_LABEL), None)
+
+
+def test_cgr_matches_libclang_oracle_on_cpp_structure(tmp_path: Path) -> None:
+ _require_cpp()
+ project = tmp_path / "cpp_proj"
+ (project / "include").mkdir(parents=True)
+ (project / "src").mkdir(parents=True)
+ (project / "include" / "shape.h").write_text(SHAPE_H, encoding="utf-8")
+ (project / "src" / "shape.cpp").write_text(SHAPE_CPP, encoding="utf-8")
+
+ src = (project / "src" / "shape.cpp").resolve()
+ include = (project / "include").resolve()
+ compdb = [
+ {
+ "directory": str(project.resolve()),
+ "file": str(src),
+ "command": f"clang++ -std=c++17 -I{include} -c {src}",
+ }
+ ]
+ (project / ec.CPP_COMPDB_FILENAME).write_text(json.dumps(compdb), encoding="utf-8")
+
+ cgr = extract_cgr_cpp_graph(project, project.name)
+ oracle = run_cpp_oracle(project)
+
+ for label, result in (
+ ("nodes", score_node_kinds(cgr, oracle, ec.CPP_SCORED_NODE_KINDS)),
+ ("edges", score_edge_types(cgr, oracle, ec.SCORED_EDGE_TYPES)),
+ ("spans", score_span(cgr, oracle, ec.CPP_SCORED_NODE_KINDS)),
+ ):
+ aggregate = _aggregate(result.rows)
+ assert aggregate is not None, (label, result.rows, result.diff)
+ assert aggregate["precision"] == 1.0 and aggregate["recall"] == 1.0, (
+ label,
+ aggregate,
+ result.diff,
+ )
+ # (H) Guard the sample is non-trivial (class + struct + 4 methods + function).
+ node_aggregate = _aggregate(
+ score_node_kinds(cgr, oracle, ec.CPP_SCORED_NODE_KINDS).rows
+ )
+ assert node_aggregate is not None and node_aggregate["tp"] >= 7, node_aggregate
+
+
+INHERIT_H = """\
+#pragma once
+struct Base { int v; };
+struct Derived : public Base {
+ int w;
+};
+"""
+
+INHERIT_CPP = """\
+#include "shapes.h"
+
+int use(Derived d) {
+ return d.v + d.w;
+}
+"""
+
+
+def test_libclang_oracle_emits_inherits_edges(tmp_path: Path) -> None:
+ # (H) The oracle must emit a base-class (CXX_BASE_SPECIFIER) edge as an INHERITS
+ # (H) name edge keyed by the base's simple name, matching cgr; otherwise cgr's
+ # (H) real inheritance edges are graded against an empty oracle set (all fp).
+ _require_cpp()
+ project = tmp_path / "inh_proj"
+ (project / "include").mkdir(parents=True)
+ (project / "src").mkdir(parents=True)
+ (project / "include" / "shapes.h").write_text(INHERIT_H, encoding="utf-8")
+ (project / "src" / "use.cpp").write_text(INHERIT_CPP, encoding="utf-8")
+
+ src = (project / "src" / "use.cpp").resolve()
+ include = (project / "include").resolve()
+ compdb = [
+ {
+ "directory": str(project.resolve()),
+ "file": str(src),
+ "command": f"clang++ -std=c++17 -I{include} -c {src}",
+ }
+ ]
+ (project / ec.CPP_COMPDB_FILENAME).write_text(json.dumps(compdb), encoding="utf-8")
+
+ cgr = extract_cgr_cpp_graph(project, project.name)
+ oracle = run_cpp_oracle(project)
+
+ result = score_name_edge_types(cgr, oracle, ec.INHERITANCE_NAME_EDGE_TYPES)
+ aggregate = _aggregate(result.rows)
+ assert aggregate is not None, (result.rows, result.diff)
+ assert aggregate["tp"] >= 1, (aggregate, result.diff)
+ assert aggregate["precision"] == 1.0 and aggregate["recall"] == 1.0, (
+ aggregate,
+ result.diff,
+ )
+
+
+def test_restrict_to_files_scopes_graph_to_universe() -> None:
+ # (H) Scale grading over a compile_commands.json must score cgr only on the
+ # (H) files the oracle actually compiled; restrict_to_files drops cgr nodes,
+ # (H) edges, and name edges that touch any out-of-universe file.
+ keep = "include/a.h"
+ drop = "test/gtest.h"
+ mod_keep = NodeKey(cs.NodeLabel.MODULE.value, keep, ec.MODULE_START_LINE)
+ cls_keep = NodeKey(cs.NodeLabel.CLASS.value, keep, 3)
+ cls_drop = NodeKey(cs.NodeLabel.CLASS.value, drop, 5)
+ graph = GraphData(
+ nodes={
+ cls_keep: DefNode(cls_keep, "Keep", 9),
+ cls_drop: DefNode(cls_drop, "Drop", 11),
+ },
+ edges={
+ EdgeKey(cs.RelationshipType.DEFINES.value, mod_keep, cls_keep),
+ EdgeKey(
+ cs.RelationshipType.DEFINES.value,
+ NodeKey(cs.NodeLabel.MODULE.value, drop, ec.MODULE_START_LINE),
+ cls_drop,
+ ),
+ },
+ name_edges={
+ NameEdge(cs.RelationshipType.INHERITS.value, cls_keep, "Other"),
+ NameEdge(cs.RelationshipType.INHERITS.value, cls_drop, "Other"),
+ },
+ )
+
+ scoped = restrict_to_files(graph, {keep})
+
+ assert set(scoped.nodes) == {cls_keep}
+ assert all(e.parent.file == keep and e.child.file == keep for e in scoped.edges)
+ assert len(scoped.edges) == 1
+ assert {n.source.file for n in scoped.name_edges} == {keep}
+ assert len(scoped.name_edges) == 1
diff --git a/codebase_rag/tests/test_cpp_out_of_class_method_calls.py b/codebase_rag/tests/test_cpp_out_of_class_method_calls.py
new file mode 100644
index 000000000..27173dc76
--- /dev/null
+++ b/codebase_rag/tests/test_cpp_out_of_class_method_calls.py
@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.tests.conftest import (
+ get_nodes,
+ get_qualified_names,
+ get_relationships,
+ run_updater,
+)
+
+# (H) An out-of-line C++ method definition (`int Calculator::add(...) {...}` at
+# (H) namespace/file scope) calling a free function. cgr's definition pass binds
+# (H) the METHOD node to the class (qn `...Calculator.add`), but the call pass
+# (H) computed the caller qn as a module-rooted free function (`...calc.add`),
+# (H) so the CALLS edge's source dangled (matched no node). The caller of a call
+# (H) inside an out-of-line method body must be the method's own node qn.
+CPP_SOURCE = """
+class Calculator {
+public:
+ int add(int a, int b);
+};
+
+int helper_fn(int x) { return x + 1; }
+
+int Calculator::add(int a, int b) {
+ return helper_fn(a) + b;
+}
+"""
+
+
+def test_out_of_class_method_call_attributed_to_method_qn(
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ project = temp_repo / "cpp_ooc_calls"
+ project.mkdir()
+ (project / "calc.cpp").write_text(CPP_SOURCE, encoding="utf-8")
+
+ run_updater(project, mock_ingestor)
+
+ method_qns = get_qualified_names(get_nodes(mock_ingestor, "Method"))
+ add_qn = next((q for q in method_qns if q.endswith(".Calculator.add")), None)
+ assert add_qn is not None, f"no Calculator.add Method node: {method_qns}"
+
+ calls = get_relationships(mock_ingestor, "CALLS")
+ # (H) ensure_relationship_batch(from_spec, rel_type, to_spec): from_spec[2] is
+ # (H) the caller qn, to_spec[2] the callee qn.
+ callers_of_helper = {
+ c.args[0][2] for c in calls if "helper_fn" in str(c.args[2][2])
+ }
+ assert add_qn in callers_of_helper, (
+ f"expected CALLS from {add_qn} to helper_fn; "
+ f"got callers {sorted(callers_of_helper)}"
+ )
diff --git a/codebase_rag/tests/test_cypher_validation.py b/codebase_rag/tests/test_cypher_validation.py
new file mode 100644
index 000000000..8a1c9017e
--- /dev/null
+++ b/codebase_rag/tests/test_cypher_validation.py
@@ -0,0 +1,258 @@
+import re
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag import exceptions as ex
+from codebase_rag.services.llm import (
+ _build_keyword_pattern,
+ _validate_call_procedures,
+ _validate_cypher_read_only,
+ _validate_no_unbounded_paths,
+)
+
+
+class TestBuildKeywordPattern:
+ def test_single_word_uses_word_boundaries(self) -> None:
+ pattern = _build_keyword_pattern("DELETE")
+ assert pattern.search("DELETE n") is not None
+ assert pattern.search("XDELETE") is None
+ assert pattern.search("DELETEX") is None
+
+ def test_multi_word_allows_whitespace_between_parts(self) -> None:
+ pattern = _build_keyword_pattern("LOAD CSV")
+ assert pattern.search("LOAD CSV") is not None
+ assert pattern.search("LOAD CSV") is not None
+ assert pattern.search("LOAD\nCSV") is not None
+ assert pattern.search("LOAD\t CSV") is not None
+
+ def test_multi_word_allows_block_comment_between_parts(self) -> None:
+ pattern = _build_keyword_pattern("LOAD CSV")
+ assert pattern.search("LOAD/*bypass*/CSV") is not None
+ assert pattern.search("LOAD /* comment */ CSV") is not None
+
+ def test_multi_word_allows_single_line_comment_between_parts(self) -> None:
+ pattern = _build_keyword_pattern("LOAD CSV")
+ assert pattern.search("LOAD //comment\nCSV") is not None
+ assert pattern.search("LOAD //\nCSV") is not None
+
+ def test_multi_word_respects_word_boundaries(self) -> None:
+ pattern = _build_keyword_pattern("LOAD CSV")
+ assert pattern.search("PRELOAD CSV") is None
+ assert pattern.search("LOAD CSVX") is None
+
+ def test_single_word_is_case_sensitive_on_input(self) -> None:
+ pattern = _build_keyword_pattern("DELETE")
+ assert pattern.search("DELETE") is not None
+ assert pattern.search("delete") is None
+
+ def test_returns_compiled_pattern(self) -> None:
+ pattern = _build_keyword_pattern("SET")
+ assert isinstance(pattern, re.Pattern)
+
+ def test_multi_word_has_dotall_flag(self) -> None:
+ pattern = _build_keyword_pattern("CREATE INDEX")
+ assert pattern.flags & re.DOTALL
+
+ def test_all_dangerous_keywords_produce_valid_patterns(self) -> None:
+ for kw in cs.CYPHER_DANGEROUS_KEYWORDS:
+ pattern = _build_keyword_pattern(kw)
+ assert pattern.search(kw) is not None
+
+
+class TestValidateCypherReadOnly:
+ def test_safe_match_query_passes(self) -> None:
+ _validate_cypher_read_only("MATCH (n) RETURN n;")
+
+ def test_safe_match_with_where_passes(self) -> None:
+ _validate_cypher_read_only("MATCH (n:Function) WHERE n.name = 'foo' RETURN n;")
+
+ def test_safe_optional_match_passes(self) -> None:
+ _validate_cypher_read_only(
+ "MATCH (a)-[:CALLS]->(b) OPTIONAL MATCH (b)-[:DEFINES]->(c) RETURN a, b, c;"
+ )
+
+ @pytest.mark.parametrize(
+ "keyword",
+ sorted(cs.CYPHER_DANGEROUS_KEYWORDS),
+ )
+ def test_rejects_all_dangerous_keywords(self, keyword: str) -> None:
+ query = f"MATCH (n) {keyword} n;"
+ with pytest.raises(ex.LLMGenerationError):
+ _validate_cypher_read_only(query)
+
+ def test_rejects_delete(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="DELETE"):
+ _validate_cypher_read_only("MATCH (n) DELETE n;")
+
+ def test_rejects_detach_delete(self) -> None:
+ with pytest.raises(ex.LLMGenerationError):
+ _validate_cypher_read_only("MATCH (n) DETACH DELETE n;")
+
+ def test_rejects_drop(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="DROP"):
+ _validate_cypher_read_only("MATCH (n) DROP INDEX idx;")
+
+ def test_rejects_set(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="SET"):
+ _validate_cypher_read_only("MATCH (n) SET n.name = 'x';")
+
+ def test_rejects_merge(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="MERGE"):
+ _validate_cypher_read_only("MERGE (n:Node {id: 1});")
+
+ def test_rejects_create(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="CREATE"):
+ _validate_cypher_read_only("CREATE (n:Node {name: 'test'});")
+
+ def test_rejects_load_csv(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="LOAD CSV"):
+ _validate_cypher_read_only(
+ "LOAD CSV FROM 'http://evil.com/data.csv' AS row;"
+ )
+
+ def test_rejects_create_index(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="CREATE INDEX"):
+ _validate_cypher_read_only("CREATE INDEX ON :Node(name);")
+
+ def test_case_insensitive(self) -> None:
+ with pytest.raises(ex.LLMGenerationError):
+ _validate_cypher_read_only("match (n) delete n;")
+
+ def test_rejects_block_comment_bypass(self) -> None:
+ with pytest.raises(ex.LLMGenerationError):
+ _validate_cypher_read_only("LOAD/*bypass*/CSV FROM 'http://evil.com';")
+
+ def test_rejects_single_line_comment_bypass(self) -> None:
+ with pytest.raises(ex.LLMGenerationError):
+ _validate_cypher_read_only("LOAD //bypass\nCSV FROM 'http://evil.com';")
+
+ def test_does_not_flag_substring_matches(self) -> None:
+ _validate_cypher_read_only("MATCH (n) WHERE n.name = 'DATASET' RETURN n;")
+
+ def test_does_not_flag_reset(self) -> None:
+ _validate_cypher_read_only("MATCH (n) WHERE n.name = 'RESET' RETURN n;")
+
+ def test_does_not_flag_created_at(self) -> None:
+ _validate_cypher_read_only("MATCH (n) WHERE n.created_at > 0 RETURN n;")
+
+ def test_error_includes_keyword_and_query(self) -> None:
+ query = "MATCH (n) DELETE n;"
+ with pytest.raises(ex.LLMGenerationError, match="DELETE") as exc_info:
+ _validate_cypher_read_only(query)
+ assert query in str(exc_info.value)
+
+ def test_rejects_foreach(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="FOREACH"):
+ _validate_cypher_read_only(
+ "MATCH p=(a)-[*]->(b) FOREACH (n IN nodes(p) | SET n.marked = true);"
+ )
+
+ def test_rejects_remove(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="REMOVE"):
+ _validate_cypher_read_only("MATCH (n) REMOVE n.prop;")
+
+ def test_call_no_longer_in_keyword_blocklist(self) -> None:
+ _validate_cypher_read_only("CALL nxalg.strongly_connected_components();")
+
+ def test_rejects_create_constraint(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="CREATE CONSTRAINT"):
+ _validate_cypher_read_only(
+ "CREATE CONSTRAINT ON (n:Node) ASSERT n.id IS UNIQUE;"
+ )
+
+ def test_rejects_multiline_block_comment_bypass(self) -> None:
+ with pytest.raises(ex.LLMGenerationError):
+ _validate_cypher_read_only("LOAD/*\nbypass\n*/CSV FROM 'http://evil.com';")
+
+
+class TestValidateNoUnboundedPaths:
+ @pytest.mark.parametrize(
+ "query",
+ [
+ "MATCH (n) RETURN n;",
+ "MATCH (a)-[:CALLS]->(b) RETURN a, b;",
+ "MATCH (a)-[:CALLS*5]->(b) RETURN a, b;",
+ "MATCH (a)-[:CALLS*1..6]->(b) RETURN a, b;",
+ "MATCH (a)-[:CALLS*..6]->(b) RETURN a, b;",
+ "MATCH (a)-[r:CALLS*1..6]->(b) RETURN r;",
+ "MATCH (a)-[*1..3]->(b) RETURN a, b;",
+ "MATCH (a)-[:CALLS*2..2]->(b) RETURN a, b;",
+ "MATCH (a)-[:CALLS*1..6 {weight: 1}]->(b) RETURN a, b;",
+ ],
+ )
+ def test_bounded_or_no_varlen_passes(self, query: str) -> None:
+ _validate_no_unbounded_paths(query)
+
+ @pytest.mark.parametrize(
+ "query",
+ [
+ "MATCH path = (a)-[:CALLS*]->(b) RETURN path;",
+ "MATCH (a)-[:CALLS*1..]->(b) RETURN a, b;",
+ "MATCH (a)-[:CALLS*..]->(b) RETURN a, b;",
+ "MATCH (a)-[*]->(b) RETURN a, b;",
+ "MATCH (a)-[r:CALLS*]->(b) RETURN r;",
+ "MATCH (a)-[:CALLS*10..]->(b) RETURN a, b;",
+ ],
+ )
+ def test_unbounded_varlen_rejected(self, query: str) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="unbounded"):
+ _validate_no_unbounded_paths(query)
+
+ def test_error_includes_query(self) -> None:
+ query = "MATCH (a)-[:CALLS*]->(b) RETURN a;"
+ with pytest.raises(ex.LLMGenerationError) as exc_info:
+ _validate_no_unbounded_paths(query)
+ assert query in str(exc_info.value)
+
+
+class TestValidateCallProcedures:
+ @pytest.mark.parametrize(
+ "query",
+ [
+ "MATCH (n) RETURN n;",
+ "CALL nxalg.strongly_connected_components() YIELD components RETURN components;",
+ "CALL nxalg.simple_cycles() YIELD cycles RETURN cycles LIMIT 10;",
+ "CALL nxalg.topological_sort() YIELD nodes RETURN nodes;",
+ "CALL pagerank.get() YIELD node, rank RETURN node, rank ORDER BY rank DESC LIMIT 10;",
+ "CALL betweenness_centrality.get() YIELD node, betweenness_centrality RETURN node;",
+ "CALL community_detection.get() YIELD node, community_id RETURN node, community_id;",
+ "CALL leiden_community_detection.get() YIELD node, community_id RETURN node;",
+ "CALL weakly_connected_components.get() YIELD node, component_id RETURN node;",
+ "CALL graph_util.ancestors(node) YIELD ancestors RETURN ancestors;",
+ "CALL path.expand(start, ['CALLS>'], ['Function'], 1, 6) YIELD path RETURN path;",
+ "CALL algo.all_simple_paths(src, tgt, ['CALLS'], 10) YIELD paths RETURN paths;",
+ "CALL bridges.get() YIELD bridges RETURN bridges;",
+ "CALL biconnected_components.get() YIELD components RETURN components;",
+ ],
+ )
+ def test_allowed_procedure_passes(self, query: str) -> None:
+ _validate_call_procedures(query)
+
+ @pytest.mark.parametrize(
+ "query",
+ [
+ "CALL db.schema.visualization();",
+ "CALL refactor.merge_nodes([a, b]) YIELD node RETURN node;",
+ "CALL create.node(['Foo'], {x: 1}) YIELD node RETURN node;",
+ "CALL export_util.json('out.json');",
+ "CALL migrate.postgresql('...') YIELD row RETURN row;",
+ "CALL mg.load('mod');",
+ "CALL csv_utils.create_csv_file('a','b');",
+ "CALL link_prediction.train();",
+ ],
+ )
+ def test_disallowed_procedure_rejected(self, query: str) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="outside the read-only"):
+ _validate_call_procedures(query)
+
+ def test_call_is_case_insensitive(self) -> None:
+ _validate_call_procedures(
+ "call nxalg.strongly_connected_components() YIELD components RETURN components;"
+ )
+
+ def test_error_includes_procedure_name(self) -> None:
+ with pytest.raises(ex.LLMGenerationError, match="refactor.merge_nodes"):
+ _validate_call_procedures(
+ "CALL refactor.merge_nodes([a, b]) YIELD n RETURN n;"
+ )
diff --git a/codebase_rag/tests/test_dead_code_command.py b/codebase_rag/tests/test_dead_code_command.py
new file mode 100644
index 000000000..aad627ee3
--- /dev/null
+++ b/codebase_rag/tests/test_dead_code_command.py
@@ -0,0 +1,226 @@
+from __future__ import annotations
+
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from codebase_rag.cli import app
+from codebase_rag.types_defs import ResultRow
+
+
+@pytest.fixture
+def runner() -> CliRunner:
+ return CliRunner()
+
+
+@pytest.fixture
+def dead_rows() -> list[ResultRow]:
+ return [
+ {
+ "label": "Function",
+ "name": "orphan_one",
+ "qualified_name": "myproj.mod.orphan_one",
+ "start_line": 5,
+ "end_line": 9,
+ },
+ {
+ "label": "Method",
+ "name": "orphan_two",
+ "qualified_name": "myproj.mod.Thing.orphan_two",
+ "start_line": 20,
+ "end_line": 25,
+ },
+ ]
+
+
+def _make_mock_ingestor(
+ *, projects: list[str], fetch_result: list[ResultRow]
+) -> MagicMock:
+ mock = MagicMock()
+ mock.list_projects.return_value = projects
+ mock.fetch_all.return_value = fetch_result
+ mock.__enter__ = MagicMock(return_value=mock)
+ mock.__exit__ = MagicMock(return_value=False)
+ return mock
+
+
+class TestDeadCodeCommand:
+ def test_lists_orphans_in_table(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code"])
+
+ assert result.exit_code == 0
+ assert "orphan_one" in result.output
+ assert "orphan_two" in result.output
+
+ def test_json_format_emits_qualified_names(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code", "--format", "json"])
+
+ assert result.exit_code == 0
+ payload = json.loads(result.output)
+ names = {row["qualified_name"] for row in payload}
+ assert names == {
+ "myproj.mod.orphan_one",
+ "myproj.mod.Thing.orphan_two",
+ }
+
+ def test_fail_on_found_exits_one_when_dead_code(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code", "--fail-on-found"])
+
+ assert result.exit_code == 1
+
+ def test_fail_on_found_exits_zero_when_clean(self, runner: CliRunner) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=[])
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code", "--fail-on-found"])
+
+ assert result.exit_code == 0
+
+ def test_explicit_project_name_used(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(
+ projects=["myproj", "other"], fetch_result=dead_rows
+ )
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code", "--project-name", "myproj"])
+
+ assert result.exit_code == 0
+ _query, params = mock_ingestor.fetch_all.call_args.args
+ assert params["project_prefix"] == "myproj."
+
+ def test_errors_when_project_ambiguous(self, runner: CliRunner) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["a", "b"], fetch_result=[])
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code"])
+
+ assert result.exit_code == 1
+ mock_ingestor.fetch_all.assert_not_called()
+
+ def test_errors_when_no_projects(self, runner: CliRunner) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=[], fetch_result=[])
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code"])
+
+ assert result.exit_code == 1
+
+ def test_entry_point_forwarded_to_query(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code", "-e", "main", "-e", "run"])
+
+ assert result.exit_code == 0
+ _query, params = mock_ingestor.fetch_all.call_args.args
+ assert params["entry_points"] == ["main", "run"]
+
+ def test_decorator_root_extends_defaults(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code", "--decorator-root", "myhandler"])
+
+ assert result.exit_code == 0
+ _query, params = mock_ingestor.fetch_all.call_args.args
+ assert "myhandler" in params["root_decorators"]
+ assert "task" in params["root_decorators"]
+
+ def test_writes_json_to_output_file(
+ self, runner: CliRunner, dead_rows: list[ResultRow], tmp_path: Path
+ ) -> None:
+ out = tmp_path / "dead.json"
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(
+ app,
+ ["dead-code", "--format", "json", "--output", str(out)],
+ )
+
+ assert result.exit_code == 0
+ payload = json.loads(out.read_text())
+ assert len(payload) == 2
+
+ def test_writes_table_to_output_file(
+ self, runner: CliRunner, dead_rows: list[ResultRow], tmp_path: Path
+ ) -> None:
+ out = tmp_path / "dead.txt"
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code", "--output", str(out)])
+
+ assert result.exit_code == 0
+ written = out.read_text()
+ assert "orphan_one" in written
+
+ def test_handles_connection_error(self, runner: CliRunner) -> None:
+ with patch(
+ "codebase_rag.cli.connect_memgraph",
+ side_effect=ConnectionError("Cannot connect"),
+ ):
+ result = runner.invoke(app, ["dead-code"])
+
+ assert result.exit_code == 1
+
+ def test_include_tests_default_passes_test_patterns(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code"])
+
+ assert result.exit_code == 0
+ query, params = mock_ingestor.fetch_all.call_args.args
+ assert "test_patterns" in params
+ assert "$test_patterns" in query
+
+ def test_no_include_tests_omits_test_patterns(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code", "--no-include-tests"])
+
+ assert result.exit_code == 0
+ query, params = mock_ingestor.fetch_all.call_args.args
+ # (H) test_patterns is still passed (it filters test modules out of the
+ # (H) module-load roots), but test functions themselves are not roots.
+ assert "test_patterns" in params
+ assert "n.path CONTAINS" not in query
+
+ def test_classes_flag_includes_class_candidates(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code", "--classes"])
+
+ assert result.exit_code == 0
+ query, _params = mock_ingestor.fetch_all.call_args.args
+ assert "Function|Method|Class" in query
+
+ def test_classes_off_by_default(
+ self, runner: CliRunner, dead_rows: list[ResultRow]
+ ) -> None:
+ mock_ingestor = _make_mock_ingestor(projects=["myproj"], fetch_result=dead_rows)
+ with patch("codebase_rag.cli.connect_memgraph", return_value=mock_ingestor):
+ result = runner.invoke(app, ["dead-code"])
+
+ assert result.exit_code == 0
+ query, _params = mock_ingestor.fetch_all.call_args.args
+ assert "Function|Method|Class" not in query
diff --git a/codebase_rag/tests/test_decorator_call_edges.py b/codebase_rag/tests/test_decorator_call_edges.py
new file mode 100644
index 000000000..5778b5efa
--- /dev/null
+++ b/codebase_rag/tests/test_decorator_call_edges.py
@@ -0,0 +1,157 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag import constants as cs
+from codebase_rag.tests.conftest import run_updater
+
+
+def _calls(mock_ingestor: MagicMock) -> list[tuple[str, str, str]]:
+ # (H) CALLS edges as (caller_label, caller_qn, callee_qn).
+ out: list[tuple[str, str, str]] = []
+ for c in mock_ingestor.ensure_relationship_batch.call_args_list:
+ if c.args[1] == cs.RelationshipType.CALLS:
+ out.append((c.args[0][0], c.args[0][2], c.args[2][2]))
+ return out
+
+
+class TestDecoratorCallEdges:
+ def test_bare_decorator_emits_module_call(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) `@task` applies task(handler) at module load -> a module-level call.
+ (temp_repo / "app.py").write_text(
+ "def task(fn):\n return fn\n\n\n@task\ndef handler():\n return 1\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ calls = _calls(mock_ingestor)
+
+ assert any(
+ label == cs.NodeLabel.MODULE
+ and caller.endswith(".app")
+ and callee.endswith(".task")
+ for label, caller, callee in calls
+ ), f"no module->task decorator edge; calls={sorted(calls)}"
+
+ def test_call_decorator_emits_module_call(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) `@register(...)` also runs at module load.
+ (temp_repo / "app.py").write_text(
+ "def register(name):\n"
+ " def wrap(fn):\n"
+ " return fn\n"
+ " return wrap\n"
+ "\n"
+ "\n"
+ '@register("x")\n'
+ "def handler():\n"
+ " return 1\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ calls = _calls(mock_ingestor)
+
+ assert any(
+ label == cs.NodeLabel.MODULE
+ and caller.endswith(".app")
+ and callee.endswith(".register")
+ for label, caller, callee in calls
+ ), f"no module->register decorator edge; calls={sorted(calls)}"
+
+ def test_class_decorator_emits_module_call(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) a bare decorator on a class also runs at module load.
+ (temp_repo / "app.py").write_text(
+ "def deco(cls):\n return cls\n\n\n@deco\nclass MyClass:\n pass\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ calls = _calls(mock_ingestor)
+
+ assert any(
+ label == cs.NodeLabel.MODULE
+ and caller.endswith(".app")
+ and callee.endswith(".deco")
+ for label, caller, callee in calls
+ ), f"no module->deco class decorator edge; calls={sorted(calls)}"
+
+ def test_alias_decorator_resolves_to_first_party(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) `@alias` where `alias = task` still calls task at module load.
+ (temp_repo / "app.py").write_text(
+ "def task(fn):\n"
+ " return fn\n"
+ "\n"
+ "\n"
+ "alias = task\n"
+ "\n"
+ "\n"
+ "@alias\n"
+ "def handler():\n"
+ " return 1\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ calls = _calls(mock_ingestor)
+
+ assert any(
+ label == cs.NodeLabel.MODULE
+ and caller.endswith(".app")
+ and callee.endswith(".task")
+ for label, caller, callee in calls
+ ), f"alias decorator not resolved; calls={sorted(calls)}"
+
+ def test_decorator_on_nested_function_not_module_attributed(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) a decorator on a function nested in another function runs when the
+ # (H) outer function is called, not at module load -> no module edge.
+ (temp_repo / "app.py").write_text(
+ "def deco(fn):\n"
+ " return fn\n"
+ "\n"
+ "\n"
+ "def outer():\n"
+ " @deco\n"
+ " def inner():\n"
+ " return 1\n"
+ "\n"
+ " return inner\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ module_callees = {
+ callee.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+ for label, _caller, callee in _calls(mock_ingestor)
+ if label == cs.NodeLabel.MODULE
+ }
+
+ assert "deco" not in module_callees
+
+ def test_undecorated_function_has_no_decorator_edge(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "app.py").write_text(
+ "def plain():\n return 1\n\n\ndef other():\n return 2\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ module_callees = {
+ callee.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+ for label, _caller, callee in _calls(mock_ingestor)
+ if label == cs.NodeLabel.MODULE
+ }
+
+ assert "plain" not in module_callees
+ assert "other" not in module_callees
diff --git a/codebase_rag/tests/test_diff_autowrap.py b/codebase_rag/tests/test_diff_autowrap.py
new file mode 100644
index 000000000..d5c9c6eb1
--- /dev/null
+++ b/codebase_rag/tests/test_diff_autowrap.py
@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from codebase_rag.main import _autowrap_diff_blocks
+
+
+class TestNoDiff:
+ def test_plain_text_unchanged(self) -> None:
+ text = "Here is some explanation without any diff."
+ assert _autowrap_diff_blocks(text) == text
+
+ def test_text_without_diff_marker_unchanged(self) -> None:
+ text = "Lines starting with - or + but no diff --git header\n- not a diff\n+ also not"
+ assert _autowrap_diff_blocks(text) == text
+
+
+class TestWrappingUnfencedDiff:
+ def test_full_git_diff_gets_fenced_as_diff(self) -> None:
+ text = (
+ "diff --git a/file.py b/file.py\n"
+ "index abc..def 100644\n"
+ "--- a/file.py\n"
+ "+++ b/file.py\n"
+ "@@ -1,3 +1,3 @@\n"
+ " context\n"
+ "-old\n"
+ "+new\n"
+ )
+ out = _autowrap_diff_blocks(text)
+ assert out.startswith("```diff\n")
+ assert out.rstrip().endswith("```")
+ assert "diff --git a/file.py b/file.py" in out
+ assert "+new" in out
+
+ def test_diff_followed_by_explanation_text(self) -> None:
+ text = (
+ "diff --git a/x b/x\n"
+ "--- a/x\n"
+ "+++ b/x\n"
+ "@@ -1 +1 @@\n"
+ "-a\n"
+ "+b\n"
+ "\n"
+ "This adds the new feature.\n"
+ )
+ out = _autowrap_diff_blocks(text)
+ assert "```diff\n" in out
+ explanation_pos = out.index("This adds the new feature.")
+ fence_close_pos = out.rindex("```", 0, explanation_pos)
+ assert fence_close_pos < explanation_pos, (
+ "explanation text must appear after the closing fence"
+ )
+ assert "diff --git" in out[:fence_close_pos]
+
+ def test_preamble_before_diff_preserved(self) -> None:
+ text = (
+ "Here are the changes I made:\n"
+ "diff --git a/foo.py b/foo.py\n"
+ "--- a/foo.py\n"
+ "+++ b/foo.py\n"
+ "@@ -1 +1 @@\n"
+ "-x\n"
+ "+y\n"
+ )
+ out = _autowrap_diff_blocks(text)
+ assert "Here are the changes I made:" in out
+ assert "```diff" in out
+
+
+class TestAlreadyFenced:
+ def test_already_fenced_diff_not_double_wrapped(self) -> None:
+ text = (
+ "Here is a diff:\n"
+ "```diff\n"
+ "diff --git a/x b/x\n"
+ "--- a/x\n"
+ "+++ b/x\n"
+ "@@ -1 +1 @@\n"
+ "-a\n"
+ "+b\n"
+ "```\n"
+ )
+ out = _autowrap_diff_blocks(text)
+ assert out.count("```diff") == 1
+ assert out.count("```") == 2
+
+ def test_fenced_with_other_language_not_rewrapped(self) -> None:
+ text = "```bash\ngit diff\ndiff --git a/x b/x\n```\n"
+ out = _autowrap_diff_blocks(text)
+ assert "```bash" in out
+ assert "```diff" not in out
diff --git a/codebase_rag/tests/test_directory_lister.py b/codebase_rag/tests/test_directory_lister.py
index 9a7f480bc..40759be36 100644
--- a/codebase_rag/tests/test_directory_lister.py
+++ b/codebase_rag/tests/test_directory_lister.py
@@ -5,6 +5,7 @@
import pytest
from pydantic_ai import Tool
+from codebase_rag import tool_errors as te
from codebase_rag.tools.directory_lister import (
DirectoryLister,
create_directory_lister_tool,
@@ -113,6 +114,24 @@ def test_list_with_hidden_files(
assert ".hidden_file" in result
assert "visible_file" in result
+ def test_list_directory_returns_error_for_path_outside_root(
+ self, directory_lister: DirectoryLister
+ ) -> None:
+ result = directory_lister.list_directory_contents("../../../etc")
+ expected = te.DIRECTORY_PATH_OUTSIDE_ROOT.format(
+ path="../../../etc", root=directory_lister.project_root
+ )
+ assert result == expected
+
+ def test_list_directory_returns_error_for_absolute_path_outside_root(
+ self, directory_lister: DirectoryLister
+ ) -> None:
+ result = directory_lister.list_directory_contents("/etc/passwd")
+ expected = te.DIRECTORY_PATH_OUTSIDE_ROOT.format(
+ path="/etc/passwd", root=directory_lister.project_root
+ )
+ assert result == expected
+
class TestGetSafePath:
def test_safe_path_with_relative_path(
diff --git a/codebase_rag/tests/test_document_analyzer.py b/codebase_rag/tests/test_document_analyzer.py
deleted file mode 100644
index 1d88dfe2f..000000000
--- a/codebase_rag/tests/test_document_analyzer.py
+++ /dev/null
@@ -1,259 +0,0 @@
-from __future__ import annotations
-
-from pathlib import Path
-from unittest.mock import MagicMock, patch
-
-import pytest
-from pydantic_ai import Tool
-
-from codebase_rag.constants import Provider
-from codebase_rag.tools.document_analyzer import (
- DocumentAnalyzer,
- _NotSupportedClient,
- create_document_analyzer_tool,
-)
-
-
-@pytest.fixture
-def temp_project_root(tmp_path: Path) -> Path:
- return tmp_path
-
-
-@pytest.fixture
-def mock_settings() -> MagicMock:
- settings = MagicMock()
- settings.active_orchestrator_config.provider = Provider.GOOGLE
- settings.active_orchestrator_config.provider_type = "api"
- settings.active_orchestrator_config.api_key = "test-api-key"
- settings.active_orchestrator_config.model_id = "gemini-1.5-flash"
- return settings
-
-
-@pytest.fixture
-def mock_genai_client() -> MagicMock:
- client = MagicMock()
- response = MagicMock()
- response.text = "Analysis result"
- client.models.generate_content.return_value = response
- return client
-
-
-class TestNotSupportedClient:
- def test_raises_not_implemented_error(self) -> None:
- client = _NotSupportedClient()
- with pytest.raises(NotImplementedError):
- client.generate_content()
-
- def test_any_attribute_raises_error(self) -> None:
- client = _NotSupportedClient()
- with pytest.raises(NotImplementedError):
- client.any_method()
-
-
-class TestDocumentAnalyzerInit:
- def test_init_resolves_project_root(
- self, temp_project_root: Path, mock_settings: MagicMock
- ) -> None:
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch("codebase_rag.tools.document_analyzer.genai.Client"):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- assert analyzer.project_root == temp_project_root.resolve()
-
- def test_init_with_google_api_provider(
- self, temp_project_root: Path, mock_settings: MagicMock
- ) -> None:
- mock_settings.active_orchestrator_config.provider = Provider.GOOGLE
- mock_settings.active_orchestrator_config.provider_type = "api"
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client"
- ) as mock_client:
- DocumentAnalyzer(str(temp_project_root))
- mock_client.assert_called_once_with(api_key="test-api-key")
-
- def test_init_with_non_google_provider(
- self, temp_project_root: Path, mock_settings: MagicMock
- ) -> None:
- mock_settings.active_orchestrator_config.provider = "anthropic"
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- assert isinstance(analyzer.client, _NotSupportedClient)
-
-
-class TestDocumentAnalyzerAnalyze:
- def test_analyze_returns_error_for_unsupported_provider(
- self, temp_project_root: Path, mock_settings: MagicMock
- ) -> None:
- mock_settings.active_orchestrator_config.provider = "anthropic"
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- result = analyzer.analyze("test.pdf", "What is this?")
- assert "Error:" in result
- assert "not supported" in result.lower()
-
- def test_analyze_file_not_found(
- self,
- temp_project_root: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
- ) -> None:
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- result = analyzer.analyze("nonexistent.pdf", "What is this?")
- assert "Error:" in result
- assert "not found" in result.lower()
-
- def test_analyze_security_path_traversal(
- self,
- temp_project_root: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
- ) -> None:
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- result = analyzer.analyze("../../../etc/passwd", "What is this?")
- assert "security" in result.lower()
-
- def test_analyze_existing_file_returns_response(
- self,
- temp_project_root: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
- ) -> None:
- test_file = temp_project_root / "test.txt"
- test_file.write_text("Test content", encoding="utf-8")
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- result = analyzer.analyze("test.txt", "What is this?")
- assert result == "Analysis result"
-
- def test_analyze_with_absolute_path(
- self,
- temp_project_root: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
- ) -> None:
- test_file = temp_project_root / "test.txt"
- test_file.write_text("Test content", encoding="utf-8")
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- result = analyzer.analyze(str(test_file), "What is this?")
- assert result == "Analysis result"
-
- def test_analyze_handles_no_text_response(
- self,
- temp_project_root: Path,
- mock_settings: MagicMock,
- ) -> None:
- mock_client = MagicMock()
- response = MagicMock()
- response.text = None
- response.candidates = None
- mock_client.models.generate_content.return_value = response
-
- test_file = temp_project_root / "test.txt"
- test_file.write_text("Test content", encoding="utf-8")
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- result = analyzer.analyze("test.txt", "What is this?")
- assert "no" in result.lower() and "content" in result.lower()
-
- def test_analyze_extracts_from_candidates(
- self,
- temp_project_root: Path,
- mock_settings: MagicMock,
- ) -> None:
- mock_client = MagicMock()
- response = MagicMock()
- response.text = None
-
- candidate = MagicMock()
- part = MagicMock()
- part.text = "Candidate text"
- candidate.content.parts = [part]
- response.candidates = [candidate]
- mock_client.models.generate_content.return_value = response
-
- test_file = temp_project_root / "test.txt"
- test_file.write_text("Test content", encoding="utf-8")
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- result = analyzer.analyze("test.txt", "What is this?")
- assert result == "Candidate text"
-
-
-class TestCreateDocumentAnalyzerTool:
- def test_creates_tool_instance(
- self,
- temp_project_root: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
- ) -> None:
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- tool = create_document_analyzer_tool(analyzer)
- assert isinstance(tool, Tool)
-
- def test_tool_has_description(
- self,
- temp_project_root: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
- ) -> None:
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- analyzer = DocumentAnalyzer(str(temp_project_root))
- tool = create_document_analyzer_tool(analyzer)
- assert tool.description is not None
- assert (
- "document" in tool.description.lower()
- or "pdf" in tool.description.lower()
- )
-
- def test_tool_has_correct_name(
- self,
- temp_project_root: Path,
- mock_settings: MagicMock,
- mock_genai_client: MagicMock,
- ) -> None:
- with patch("codebase_rag.tools.document_analyzer.settings", mock_settings):
- with patch(
- "codebase_rag.tools.document_analyzer.genai.Client",
- return_value=mock_genai_client,
- ):
- from codebase_rag.tools.tool_descriptions import AgenticToolName
-
- analyzer = DocumentAnalyzer(str(temp_project_root))
- tool = create_document_analyzer_tool(analyzer)
- assert tool.name == AgenticToolName.ANALYZE_DOCUMENT
diff --git a/codebase_rag/tests/test_duplicate_qn_definitions.py b/codebase_rag/tests/test_duplicate_qn_definitions.py
new file mode 100644
index 000000000..d3670086c
--- /dev/null
+++ b/codebase_rag/tests/test_duplicate_qn_definitions.py
@@ -0,0 +1,184 @@
+# (H) Regression tests for the duplicate-qualified-name finding surfaced by the
+# (H) evals/ harness: the `if has_x(): else: ` import-fallback
+# (H) idiom defines one qualified name twice. cgr used to collapse the two into a
+# (H) single node (last-writer-wins kept the else-branch stub). Both definitions
+# (H) must survive as distinct nodes, and a call must link to BOTH.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "dupproj"
+
+MODULE_SRC = """import os
+
+
+if os.environ.get("FLAG"):
+
+ def impl() -> str:
+ return "real"
+
+else:
+
+ def impl() -> str:
+ return "stub"
+
+
+def caller() -> str:
+ return impl()
+"""
+
+_RelTuple = tuple[str, PropertyValue, str, str, PropertyValue]
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.nodes: dict[tuple[str, PropertyValue], PropertyDict] = {}
+ self.rels: list[_RelTuple] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ uid = properties[cs.NODE_UNIQUE_CONSTRAINTS[label]]
+ self.nodes[(str(label), uid)] = dict(properties)
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append(
+ (
+ str(from_spec[0]),
+ from_spec[2],
+ str(rel_type),
+ str(to_spec[0]),
+ to_spec[2],
+ )
+ )
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _build(tmp_path: Path, src: str = MODULE_SRC) -> _Capture:
+ (tmp_path / "m.py").write_text(src)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return cap
+
+
+class TestDuplicateQualifiedNameDefinitions:
+ def test_both_branch_definitions_become_distinct_nodes(
+ self, tmp_path: Path
+ ) -> None:
+ cap = _build(tmp_path)
+ impl_start_lines = sorted(
+ int(props[cs.KEY_START_LINE])
+ for (label, _uid), props in cap.nodes.items()
+ if label == cs.NodeLabel.FUNCTION
+ and props.get(cs.KEY_NAME) == "impl"
+ and props.get(cs.KEY_START_LINE) is not None
+ )
+ assert impl_start_lines == [6, 11], impl_start_lines
+
+ def test_call_links_to_both_duplicate_definitions(self, tmp_path: Path) -> None:
+ cap = _build(tmp_path)
+ calls_to_impl = [
+ target
+ for (_fl, from_val, rel_type, _tl, target) in cap.rels
+ if rel_type == cs.RelationshipType.CALLS
+ and str(from_val).endswith(".caller")
+ and ".impl" in str(target)
+ ]
+ assert len(calls_to_impl) == 2, calls_to_impl
+
+
+CLASS_SRC = """import os
+
+
+if os.environ.get("FLAG"):
+
+ class Widget:
+ def render(self) -> str:
+ return "real"
+
+else:
+
+ class Widget:
+ def render(self) -> str:
+ return "stub"
+"""
+
+
+class TestDuplicateQualifiedNameClasses:
+ def test_both_branch_classes_become_distinct_nodes(self, tmp_path: Path) -> None:
+ cap = _build(tmp_path, CLASS_SRC)
+ widget_start_lines = sorted(
+ int(props[cs.KEY_START_LINE])
+ for (label, _uid), props in cap.nodes.items()
+ if label == cs.NodeLabel.CLASS
+ and props.get(cs.KEY_NAME) == "Widget"
+ and props.get(cs.KEY_START_LINE) is not None
+ )
+ assert widget_start_lines == [6, 12], widget_start_lines
+
+ def test_methods_of_both_branch_classes_survive(self, tmp_path: Path) -> None:
+ cap = _build(tmp_path, CLASS_SRC)
+ render_start_lines = sorted(
+ int(props[cs.KEY_START_LINE])
+ for (label, _uid), props in cap.nodes.items()
+ if label == cs.NodeLabel.METHOD
+ and props.get(cs.KEY_NAME) == "render"
+ and props.get(cs.KEY_START_LINE) is not None
+ )
+ assert render_start_lines == [7, 13], render_start_lines
+
+
+METHOD_DUP_SRC = """import os
+
+
+class Service:
+
+ if os.environ.get("FLAG"):
+
+ def run(self) -> str:
+ return "real"
+
+ else:
+
+ def run(self) -> str:
+ return "stub"
+"""
+
+
+class TestDuplicateQualifiedNameMethodsInOneClass:
+ def test_both_branch_methods_in_one_class_survive(self, tmp_path: Path) -> None:
+ cap = _build(tmp_path, METHOD_DUP_SRC)
+ run_start_lines = sorted(
+ int(props[cs.KEY_START_LINE])
+ for (label, _uid), props in cap.nodes.items()
+ if label == cs.NodeLabel.METHOD
+ and props.get(cs.KEY_NAME) == "run"
+ and props.get(cs.KEY_START_LINE) is not None
+ )
+ assert run_start_lines == [8, 13], run_start_lines
diff --git a/codebase_rag/tests/test_embedder.py b/codebase_rag/tests/test_embedder.py
index 401044582..6eb009f3e 100644
--- a/codebase_rag/tests/test_embedder.py
+++ b/codebase_rag/tests/test_embedder.py
@@ -1,10 +1,13 @@
from __future__ import annotations
+import tempfile
from collections.abc import Generator
+from pathlib import Path
from unittest.mock import MagicMock, patch
import pytest
+from codebase_rag.embedder import EmbeddingCache, clear_embedding_cache
from codebase_rag.utils.dependencies import has_torch, has_transformers
@@ -44,6 +47,13 @@ def reset_model_cache() -> Generator[None, None, None]:
get_model.cache_clear()
+@pytest.fixture(autouse=True)
+def reset_cache() -> Generator[None, None, None]:
+ clear_embedding_cache()
+ yield
+ clear_embedding_cache()
+
+
@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
def test_embed_code_returns_768_dimensional_vector(
mock_unixcoder: MagicMock, reset_model_cache: None
@@ -146,6 +156,65 @@ def test_get_model_does_not_use_cuda_when_unavailable(reset_model_cache: None) -
mock_instance.cuda.assert_not_called()
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_select_device_prefers_cuda() -> None:
+ from codebase_rag.embedder import (
+ _select_device, # ty: ignore[possibly-missing-import]
+ )
+
+ with patch("codebase_rag.embedder.torch.cuda.is_available", return_value=True):
+ with patch(
+ "codebase_rag.embedder.torch.backends.mps.is_available", return_value=True
+ ):
+ assert _select_device() == "cuda"
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_select_device_uses_mps_when_cuda_unavailable() -> None:
+ from codebase_rag.embedder import (
+ _select_device, # ty: ignore[possibly-missing-import]
+ )
+
+ with patch("codebase_rag.embedder.torch.cuda.is_available", return_value=False):
+ with patch(
+ "codebase_rag.embedder.torch.backends.mps.is_available", return_value=True
+ ):
+ assert _select_device() == "mps"
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_select_device_falls_back_to_cpu() -> None:
+ from codebase_rag.embedder import (
+ _select_device, # ty: ignore[possibly-missing-import]
+ )
+
+ with patch("codebase_rag.embedder.torch.cuda.is_available", return_value=False):
+ with patch(
+ "codebase_rag.embedder.torch.backends.mps.is_available", return_value=False
+ ):
+ assert _select_device() == "cpu"
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_get_model_moves_to_mps_when_available(reset_model_cache: None) -> None:
+ from codebase_rag.embedder import get_model # ty: ignore[possibly-missing-import]
+
+ with patch("codebase_rag.embedder.UniXcoder") as mock_unixcoder_class:
+ mock_instance = MagicMock()
+ mock_instance.eval.return_value = mock_instance
+ mock_instance.to.return_value = mock_instance
+ mock_unixcoder_class.return_value = mock_instance
+
+ with patch("codebase_rag.embedder.torch.cuda.is_available", return_value=False):
+ with patch(
+ "codebase_rag.embedder.torch.backends.mps.is_available",
+ return_value=True,
+ ):
+ get_model()
+
+ mock_instance.to.assert_called_once_with("mps")
+
+
@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
@pytest.mark.slow
def test_embed_code_integration(reset_model_cache: None) -> None:
@@ -192,3 +261,311 @@ def test_embed_code_raises_without_dependencies() -> None:
with pytest.raises(RuntimeError, match="Semantic search requires"):
embed_code("x = 1")
+
+
+def test_embedding_cache_put_and_get() -> None:
+ cache = EmbeddingCache()
+ embedding = [0.1, 0.2, 0.3]
+ cache.put("def foo(): pass", embedding)
+ assert cache.get("def foo(): pass") == embedding
+
+
+def test_embedding_cache_miss_returns_none() -> None:
+ cache = EmbeddingCache()
+ assert cache.get("unknown code") is None
+
+
+def test_embedding_cache_different_content_different_key() -> None:
+ cache = EmbeddingCache()
+ cache.put("code_a", [1.0])
+ cache.put("code_b", [2.0])
+ assert cache.get("code_a") == [1.0]
+ assert cache.get("code_b") == [2.0]
+
+
+def test_embedding_cache_overwrite() -> None:
+ cache = EmbeddingCache()
+ cache.put("code_a", [1.0])
+ cache.put("code_a", [9.9])
+ assert cache.get("code_a") == [9.9]
+
+
+def test_embedding_cache_len() -> None:
+ cache = EmbeddingCache()
+ assert len(cache) == 0
+ cache.put("a", [1.0])
+ assert len(cache) == 1
+ cache.put("b", [2.0])
+ assert len(cache) == 2
+
+
+def test_embedding_cache_clear() -> None:
+ cache = EmbeddingCache()
+ cache.put("a", [1.0])
+ cache.put("b", [2.0])
+ cache.clear()
+ assert len(cache) == 0
+ assert cache.get("a") is None
+
+
+def test_embedding_cache_get_many() -> None:
+ cache = EmbeddingCache()
+ cache.put("a", [1.0])
+ cache.put("b", [2.0])
+ results = cache.get_many(["a", "c", "b"])
+ assert results == {0: [1.0], 2: [2.0]}
+
+
+def test_embedding_cache_put_many() -> None:
+ cache = EmbeddingCache()
+ cache.put_many(["x", "y"], [[1.0], [2.0]])
+ assert cache.get("x") == [1.0]
+ assert cache.get("y") == [2.0]
+
+
+def test_embedding_cache_save_and_load() -> None:
+ with tempfile.TemporaryDirectory() as tmpdir:
+ cache_path = Path(tmpdir) / "test_cache.json"
+ cache = EmbeddingCache(path=cache_path)
+ cache.put("hello", [0.5, 0.6])
+ cache.save()
+
+ assert cache_path.exists()
+
+ cache2 = EmbeddingCache(path=cache_path)
+ cache2.load()
+ assert cache2.get("hello") == [0.5, 0.6]
+
+
+def test_embedding_cache_load_nonexistent_path() -> None:
+ cache = EmbeddingCache(path=Path("/nonexistent/path/cache.json"))
+ cache.load()
+ assert len(cache) == 0
+
+
+def test_embedding_cache_load_corrupt_file() -> None:
+ with tempfile.TemporaryDirectory() as tmpdir:
+ cache_path = Path(tmpdir) / "corrupt.json"
+ cache_path.write_text("not valid json data", encoding="utf-8")
+ cache = EmbeddingCache(path=cache_path)
+ cache.load()
+ assert len(cache) == 0
+
+
+def test_embedding_cache_save_no_path() -> None:
+ cache = EmbeddingCache(path=None)
+ cache.put("a", [1.0])
+ cache.save()
+
+
+def test_embedding_cache_load_no_path() -> None:
+ cache = EmbeddingCache(path=None)
+ cache.load()
+ assert len(cache) == 0
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_embed_code_uses_cache(
+ mock_unixcoder: MagicMock, reset_model_cache: None
+) -> None:
+ import torch
+
+ from codebase_rag.embedder import embed_code, get_embedding_cache
+
+ mock_embedding = torch.zeros(1, 768)
+ mock_unixcoder.return_value = (torch.zeros(1, 5, 768), mock_embedding)
+
+ cache = get_embedding_cache()
+ cache.put("cached_code", [0.42] * 768)
+
+ with patch("codebase_rag.embedder.get_model", return_value=mock_unixcoder):
+ result = embed_code("cached_code")
+
+ assert result == [0.42] * 768
+ mock_unixcoder.tokenize.assert_not_called()
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_embed_code_populates_cache(
+ mock_unixcoder: MagicMock, reset_model_cache: None
+) -> None:
+ import torch
+
+ from codebase_rag.embedder import embed_code, get_embedding_cache
+
+ mock_embedding = torch.ones(1, 768)
+ mock_unixcoder.return_value = (torch.zeros(1, 5, 768), mock_embedding)
+
+ with patch("codebase_rag.embedder.get_model", return_value=mock_unixcoder):
+ embed_code("new_code")
+
+ cache = get_embedding_cache()
+ assert cache.get("new_code") is not None
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_embed_code_batch_empty_list(reset_model_cache: None) -> None:
+ from codebase_rag.embedder import embed_code_batch
+
+ assert embed_code_batch([]) == []
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_embed_code_batch_returns_correct_count(
+ mock_unixcoder: MagicMock, reset_model_cache: None
+) -> None:
+ import torch
+
+ from codebase_rag.embedder import embed_code_batch
+
+ snippets = ["def a(): pass", "def b(): pass", "def c(): pass"]
+ mock_unixcoder.tokenize.return_value = [[1, 2, 3]] * 3
+ mock_embedding = torch.zeros(3, 768)
+ mock_unixcoder.return_value = (torch.zeros(3, 5, 768), mock_embedding)
+
+ with patch("codebase_rag.embedder.get_model", return_value=mock_unixcoder):
+ results = embed_code_batch(snippets)
+
+ assert len(results) == 3
+ assert all(len(emb) == 768 for emb in results)
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_embed_code_batch_uses_padding(
+ mock_unixcoder: MagicMock, reset_model_cache: None
+) -> None:
+ import torch
+
+ from codebase_rag.embedder import embed_code_batch
+
+ snippets = ["short", "longer code here"]
+ mock_unixcoder.tokenize.return_value = [[1, 2, 3, 0, 0], [1, 2, 3, 4, 5]]
+ mock_embedding = torch.zeros(2, 768)
+ mock_unixcoder.return_value = (torch.zeros(2, 5, 768), mock_embedding)
+
+ with patch("codebase_rag.embedder.get_model", return_value=mock_unixcoder):
+ embed_code_batch(snippets)
+
+ mock_unixcoder.tokenize.assert_called_once_with(
+ snippets, max_length=512, padding=True
+ )
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_embed_code_batch_cache_hit(
+ mock_unixcoder: MagicMock, reset_model_cache: None
+) -> None:
+ from codebase_rag.embedder import embed_code_batch, get_embedding_cache
+
+ cache = get_embedding_cache()
+ cache.put("a", [1.0] * 768)
+ cache.put("b", [2.0] * 768)
+
+ with patch("codebase_rag.embedder.get_model", return_value=mock_unixcoder):
+ results = embed_code_batch(["a", "b"])
+
+ mock_unixcoder.tokenize.assert_not_called()
+ assert results == [[1.0] * 768, [2.0] * 768]
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_embed_code_batch_partial_cache(
+ mock_unixcoder: MagicMock, reset_model_cache: None
+) -> None:
+ import torch
+
+ from codebase_rag.embedder import embed_code_batch, get_embedding_cache
+
+ cache = get_embedding_cache()
+ cache.put("a", [1.0] * 768)
+
+ mock_unixcoder.tokenize.return_value = [[1, 2, 3]]
+ mock_embedding = torch.full((1, 768), 3.0)
+ mock_unixcoder.return_value = (torch.zeros(1, 5, 768), mock_embedding)
+
+ with patch("codebase_rag.embedder.get_model", return_value=mock_unixcoder):
+ results = embed_code_batch(["a", "b"])
+
+ assert results[0] == [1.0] * 768
+ assert results[1] == [3.0] * 768
+ mock_unixcoder.tokenize.assert_called_once_with(["b"], max_length=512, padding=True)
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_embed_code_batch_populates_cache(
+ mock_unixcoder: MagicMock, reset_model_cache: None
+) -> None:
+ import torch
+
+ from codebase_rag.embedder import embed_code_batch, get_embedding_cache
+
+ mock_unixcoder.tokenize.return_value = [[1, 2, 3]]
+ mock_embedding = torch.ones(1, 768)
+ mock_unixcoder.return_value = (torch.zeros(1, 5, 768), mock_embedding)
+
+ with patch("codebase_rag.embedder.get_model", return_value=mock_unixcoder):
+ embed_code_batch(["new_snippet"])
+
+ cache = get_embedding_cache()
+ assert cache.get("new_snippet") is not None
+
+
+@pytest.mark.skipif(not _has_semantic_deps(), reason="torch/transformers not installed")
+def test_embed_code_batch_respects_batch_size(
+ mock_unixcoder: MagicMock, reset_model_cache: None
+) -> None:
+ import torch
+
+ from codebase_rag.embedder import embed_code_batch
+
+ snippets = [f"def f{i}(): pass" for i in range(5)]
+
+ def side_effect_tokenize(batch: list[str], **kwargs: int | bool) -> list[list[int]]:
+ return [[1, 2, 3]] * len(batch)
+
+ mock_unixcoder.tokenize.side_effect = side_effect_tokenize
+
+ def side_effect_forward(tensor: torch.Tensor) -> tuple[torch.Tensor, torch.Tensor]:
+ n = tensor.shape[0]
+ return torch.zeros(n, 5, 768), torch.zeros(n, 768)
+
+ mock_unixcoder.side_effect = side_effect_forward
+
+ with patch("codebase_rag.embedder.get_model", return_value=mock_unixcoder):
+ results = embed_code_batch(snippets, batch_size=2)
+
+ assert len(results) == 5
+ assert mock_unixcoder.tokenize.call_count == 3
+
+
+def test_embed_code_batch_raises_without_dependencies() -> None:
+ if _has_semantic_deps():
+ pytest.skip("Dependencies are installed")
+
+ from codebase_rag.embedder import embed_code_batch
+
+ with pytest.raises(RuntimeError, match="Semantic search requires"):
+ embed_code_batch(["x = 1"])
+
+
+def test_embedding_default_batch_size_at_least_64() -> None:
+ from codebase_rag import constants as cs
+
+ assert cs.EMBEDDING_DEFAULT_BATCH_SIZE >= 64
+
+
+def test_embedding_cache_persistence_roundtrip() -> None:
+ with tempfile.TemporaryDirectory() as tmpdir:
+ cache_path = Path(tmpdir) / "subdir" / "cache.json"
+
+ cache1 = EmbeddingCache(path=cache_path)
+ cache1.put("fn_a", [0.1, 0.2])
+ cache1.put("fn_b", [0.3, 0.4])
+ cache1.save()
+
+ cache2 = EmbeddingCache(path=cache_path)
+ cache2.load()
+ assert cache2.get("fn_a") == [0.1, 0.2]
+ assert cache2.get("fn_b") == [0.3, 0.4]
+ assert cache2.get("fn_c") is None
+ assert len(cache2) == 2
diff --git a/codebase_rag/tests/test_eval_imports_internal_modules.py b/codebase_rag/tests/test_eval_imports_internal_modules.py
new file mode 100644
index 000000000..4a30a707b
--- /dev/null
+++ b/codebase_rag/tests/test_eval_imports_internal_modules.py
@@ -0,0 +1,38 @@
+# (H) Covers the L1 eval (evals/cgr_graph.py): cgr emits placeholder MODULE nodes
+# (H) for unresolved imports whose path is the dotted import name (e.g.
+# (H) "thrift.TTornado"). Those must not be treated as internal import targets when
+# (H) scoring IMPORTS, or every "from .x import ..." collapses onto them as a
+# (H) false positive. Only real in-repo .py modules count as internal.
+from __future__ import annotations
+
+from codebase_rag import constants as cs
+from evals.cgr_graph import _CapturingIngestor, _to_graph_data
+
+_MODULE = cs.NodeLabel.MODULE.value
+_IMPORTS = cs.RelationshipType.IMPORTS.value
+
+
+def _module(ingestor: _CapturingIngestor, qn: str, path: str) -> None:
+ ingestor.ensure_node_batch(
+ _MODULE,
+ {cs.KEY_QUALIFIED_NAME: qn, cs.KEY_NAME: qn, cs.KEY_PATH: path},
+ )
+
+
+def test_import_placeholder_module_not_scored_as_internal() -> None:
+ ingestor = _CapturingIngestor()
+ _module(ingestor, "proj.src", "src.py")
+ _module(ingestor, "proj.real", "pkg/real.py")
+ # (H) Placeholder for an unresolved import: path is the dotted name, not a file.
+ _module(ingestor, "proj.placeholder", "proj.placeholder")
+
+ for target in ("proj.real", "proj.placeholder"):
+ ingestor.ensure_relationship_batch(
+ (_MODULE, cs.KEY_QUALIFIED_NAME, "proj.src"),
+ _IMPORTS,
+ (_MODULE, cs.KEY_QUALIFIED_NAME, target),
+ )
+
+ graph = _to_graph_data(ingestor, "proj")
+ import_targets = {e.target_name for e in graph.name_edges if e.rel_type == _IMPORTS}
+ assert import_targets == {"pkg/real.py"}, import_targets
diff --git a/codebase_rag/tests/test_eval_module_calls.py b/codebase_rag/tests/test_eval_module_calls.py
new file mode 100644
index 000000000..b63938676
--- /dev/null
+++ b/codebase_rag/tests/test_eval_module_calls.py
@@ -0,0 +1,160 @@
+from __future__ import annotations
+
+from pathlib import Path
+
+from evals.module_calls import (
+ cgr_module_calls,
+ oracle_module_calls,
+ score_module_calls,
+)
+
+_FIXTURE = """def make_default():
+ return 1
+
+
+def helper():
+ return 2
+
+
+def main():
+ helper()
+
+
+def with_default(x=make_default()):
+ return x
+
+
+CONFIG = make_default()
+
+
+if __name__ == "__main__":
+ main()
+"""
+
+
+def _names(edges: set[tuple[str, ...]]) -> set[str]:
+ return {e.target_name for e in edges}
+
+
+class TestModuleCallEval:
+ def _write(self, tmp_path: Path) -> Path:
+ proj = tmp_path / "proj"
+ proj.mkdir()
+ (proj / "app.py").write_text(_FIXTURE, encoding="utf-8")
+ return proj
+
+ def test_oracle_counts_only_definition_time_calls(self, tmp_path: Path) -> None:
+ proj = self._write(tmp_path)
+ oracle = oracle_module_calls(proj, "proj")
+
+ # (H) make_default runs at module load (CONFIG = ... and the default arg);
+ # (H) main runs from the `if __name__` block; helper only runs inside main's
+ # (H) body, so it is NOT a module-level call.
+ assert _names(oracle) == {"make_default", "main"}
+
+ def test_cgr_matches_oracle_module_calls(self, tmp_path: Path) -> None:
+ proj = self._write(tmp_path)
+ cgr = cgr_module_calls(proj, "proj")
+ oracle = oracle_module_calls(proj, "proj")
+
+ _tp, fp, fn, precision, recall = score_module_calls(cgr, oracle)
+
+ assert fp == 0, f"spurious module calls: {sorted(_names(cgr - oracle))}"
+ assert fn == 0, f"missed module calls: {sorted(_names(oracle - cgr))}"
+ assert precision == 1.0
+ assert recall == 1.0
+
+ def test_nested_call_is_not_module_attributed(self, tmp_path: Path) -> None:
+ proj = self._write(tmp_path)
+ cgr = cgr_module_calls(proj, "proj")
+
+ assert "helper" not in _names(cgr)
+
+ def _oracle_for(self, tmp_path: Path, source: str) -> set[str]:
+ proj = tmp_path / "proj"
+ proj.mkdir()
+ (proj / "app.py").write_text(source, encoding="utf-8")
+ return _names(oracle_module_calls(proj, "proj"))
+
+ def test_lambda_body_call_is_deferred(self, tmp_path: Path) -> None:
+ # (H) `helper` runs only when `work()` is called, not at import.
+ names = self._oracle_for(
+ tmp_path,
+ "def helper():\n return 1\n\n\nwork = lambda: helper()\n",
+ )
+ assert "helper" not in names
+
+ def test_generator_expression_call_is_deferred(self, tmp_path: Path) -> None:
+ # (H) a generator is lazy: `helper` runs only when the generator is consumed.
+ names = self._oracle_for(
+ tmp_path,
+ "def helper():\n return 1\n\n\ngen = (helper() for _ in range(2))\n",
+ )
+ assert "helper" not in names
+
+ def test_generator_outermost_iterable_is_eager(self, tmp_path: Path) -> None:
+ # (H) the first iterable of a generator is evaluated when the generator is
+ # (H) created (at import), so `load_items` is a module call but the lazy
+ # (H) body call `helper` is not.
+ names = self._oracle_for(
+ tmp_path,
+ "def helper():\n return 1\n\n\n"
+ "def load_items():\n return [1]\n\n\n"
+ "gen = (helper(x) for x in load_items())\n",
+ )
+ assert "load_items" in names
+ assert "helper" not in names
+
+ def test_list_comprehension_call_is_module_attributed(self, tmp_path: Path) -> None:
+ # (H) a list comprehension runs eagerly at import, so its call counts.
+ names = self._oracle_for(
+ tmp_path,
+ "def helper():\n return 1\n\n\nout = [helper() for _ in range(2)]\n",
+ )
+ assert "helper" in names
+
+ def test_class_decorator_is_module_attributed(self, tmp_path: Path) -> None:
+ # (H) a bare class decorator runs at module load -> a module call.
+ names = self._oracle_for(
+ tmp_path,
+ "def deco(cls):\n return cls\n\n\n@deco\nclass Widget:\n pass\n",
+ )
+ assert "deco" in names
+
+ def _cgr_for(self, tmp_path: Path, source: str) -> set[str]:
+ proj = tmp_path / "proj"
+ proj.mkdir()
+ (proj / "app.py").write_text(source, encoding="utf-8")
+ return _names(cgr_module_calls(proj, "proj"))
+
+ def test_classless_module_construction_credited_via_instantiates(
+ self, tmp_path: Path
+ ) -> None:
+ # (H) a dataclass has no explicit __init__, so cgr emits no CALLS for its
+ # (H) construction, only INSTANTIATES -> the class. The eval must still
+ # (H) credit the module-scope `Config(1)` so L2 recall stays 1.0.
+ source = (
+ "from dataclasses import dataclass\n\n\n"
+ "@dataclass\nclass Config:\n n: int\n\n\n"
+ "CONFIG = Config(1)\n"
+ )
+ assert "Config" in self._cgr_for(tmp_path, source)
+
+ def test_return_annotation_counted_without_future_import(
+ self, tmp_path: Path
+ ) -> None:
+ # (H) without postponed annotations, `Result()` runs at import.
+ names = self._oracle_for(
+ tmp_path,
+ "def Result():\n return 1\n\n\ndef route() -> Result():\n return 1\n",
+ )
+ assert "Result" in names
+
+ def test_annotation_not_counted_with_future_import(self, tmp_path: Path) -> None:
+ # (H) with postponed annotations, the annotation is a string and never runs.
+ names = self._oracle_for(
+ tmp_path,
+ "from __future__ import annotations\n\n\n"
+ "def Result():\n return 1\n\n\ndef route() -> Result():\n return 1\n",
+ )
+ assert "Result" not in names
diff --git a/codebase_rag/tests/test_eval_score_span.py b/codebase_rag/tests/test_eval_score_span.py
new file mode 100644
index 000000000..2b1031915
--- /dev/null
+++ b/codebase_rag/tests/test_eval_score_span.py
@@ -0,0 +1,54 @@
+# (H) Covers the L1 eval span grading (evals/score.score_span): among nodes both
+# (H) cgr and the oracle identify by (kind, file, start), it grades how often cgr's
+# (H) end_line agrees with the oracle's. A disagreement must surface as fp+fn (not
+# (H) be masked by node identity already being 1.0), and nodes only one side has
+# (H) must not be graded at all.
+from __future__ import annotations
+
+from codebase_rag import constants as cs
+from evals import constants as ec
+from evals.score import score_span
+from evals.types_defs import DefNode, GraphData, NodeKey
+
+_FUNC = cs.NodeLabel.FUNCTION.value
+_KINDS = (cs.NodeLabel.FUNCTION,)
+
+
+def _graph(*nodes: tuple[str, int, int]) -> GraphData:
+ # (H) Each node is (file, start, end) for a Function.
+ mapping: dict[NodeKey, DefNode] = {}
+ for file, start, end in nodes:
+ key = NodeKey(_FUNC, file, start)
+ mapping[key] = DefNode(key, "f", end)
+ return GraphData(nodes=mapping, edges=set(), name_edges=set())
+
+
+def test_span_exact_match_scores_perfect() -> None:
+ cgr = _graph(("a.rs", 1, 5), ("a.rs", 10, 20))
+ oracle = _graph(("a.rs", 1, 5), ("a.rs", 10, 20))
+ by_label = {row["label"]: row for row in score_span(cgr, oracle, _KINDS).rows}
+ row = by_label[_FUNC]
+ assert row["precision"] == 1.0 and row["recall"] == 1.0
+ assert row["tp"] == 2 and row["fp"] == 0 and row["fn"] == 0
+
+
+def test_span_end_line_mismatch_is_penalized_and_surfaced() -> None:
+ cgr = _graph(("a.rs", 1, 5), ("a.rs", 10, 99))
+ oracle = _graph(("a.rs", 1, 5), ("a.rs", 10, 20))
+ result = score_span(cgr, oracle, _KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ row = by_label[_FUNC]
+ assert row["tp"] == 1 and row["fp"] == 1 and row["fn"] == 1
+ assert row["precision"] == 0.5 and row["recall"] == 0.5
+ bucket = result.diff[ec.DIFF_SPAN_PREFIX + _FUNC]
+ assert any("10-20" in line for line in bucket["missing"]), bucket
+ assert any("10-99" in line for line in bucket["extra"]), bucket
+
+
+def test_span_only_grades_co_identified_nodes() -> None:
+ # (H) cgr has an extra node (start 30) the oracle lacks; it must not be graded.
+ cgr = _graph(("a.rs", 1, 5), ("a.rs", 30, 40))
+ oracle = _graph(("a.rs", 1, 5))
+ by_label = {row["label"]: row for row in score_span(cgr, oracle, _KINDS).rows}
+ row = by_label[_FUNC]
+ assert row["tp"] == 1 and row["fp"] == 0 and row["fn"] == 0
diff --git a/codebase_rag/tests/test_external_package_name_collision.py b/codebase_rag/tests/test_external_package_name_collision.py
new file mode 100644
index 000000000..f5c6d51d7
--- /dev/null
+++ b/codebase_rag/tests/test_external_package_name_collision.py
@@ -0,0 +1,87 @@
+# (H) L2 residual from the evals/ harness: when cgr is pointed at a directory that
+# (H) is itself a package (has __init__.py), a bare absolute import like
+# (H) `from mcp.server import X` is the EXTERNAL top-level package, not the internal
+# (H) sibling subpackage `.mcp` (which is reachable only as that dotted name
+# (H) or relatively). cgr used to mis-resolve it to the internal package.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _build(tmp_path: Path, importer: str, src: str) -> _Capture:
+ (tmp_path / "__init__.py").touch()
+ mcp = tmp_path / "mcp"
+ mcp.mkdir()
+ mcp.joinpath("__init__.py").touch()
+ mcp.joinpath("server.py").write_text("Thing = 1\n")
+ (tmp_path / importer).write_text(src)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return cap
+
+
+def _imports(cap: _Capture) -> set[tuple[PropertyValue, PropertyValue]]:
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.IMPORTS
+ }
+
+
+class TestExternalPackageNameCollision:
+ def test_bare_absolute_import_is_external_not_internal(
+ self, tmp_path: Path
+ ) -> None:
+ cap = _build(
+ tmp_path, "client.py", "from mcp.server import Thing\n\nx = Thing\n"
+ )
+ edges = _imports(cap)
+ assert ("proj.client", "proj.mcp.server") not in edges, edges
+ assert ("proj.client", "proj.mcp") not in edges, edges
+
+ def test_relative_import_to_subpackage_still_internal(self, tmp_path: Path) -> None:
+ cap = _build(
+ tmp_path, "client.py", "from .mcp.server import Thing\n\nx = Thing\n"
+ )
+ edges = _imports(cap)
+ assert ("proj.client", "proj.mcp.server") in edges, edges
diff --git a/codebase_rag/tests/test_function_ingest.py b/codebase_rag/tests/test_function_ingest.py
index 814380ce4..1d7b6e8a6 100644
--- a/codebase_rag/tests/test_function_ingest.py
+++ b/codebase_rag/tests/test_function_ingest.py
@@ -234,7 +234,7 @@ def inner_func():
lang_config = queries[cs.SupportedLanguage.PYTHON]["config"]
result = definition_processor._is_method(inner_func, lang_config)
- assert result is True
+ assert result is False
class TestFormatNestedQn:
@@ -317,7 +317,7 @@ def test_top_level_function(
lang_config = queries[cs.SupportedLanguage.PYTHON]["config"]
parent_type, parent_qn = definition_processor._determine_function_parent(
- func_node, "proj.module", lang_config
+ func_node, "proj.module.my_function", "proj.module", lang_config
)
assert parent_type == "Module"
assert parent_qn == "proj.module"
@@ -342,7 +342,7 @@ def inner():
lang_config = queries[cs.SupportedLanguage.PYTHON]["config"]
parent_type, parent_qn = definition_processor._determine_function_parent(
- inner_func, "proj.module", lang_config
+ inner_func, "proj.module.outer.inner", "proj.module", lang_config
)
assert parent_type == "Function"
assert parent_qn == "proj.module.outer"
@@ -466,7 +466,9 @@ def test_basic_function_props(
is_exported=False,
)
- result = definition_processor._build_function_props(func_node, resolution)
+ result = definition_processor._build_function_props(
+ func_node, resolution, "proj.module"
+ )
assert result["qualified_name"] == "proj.module.my_function"
assert result["name"] == "my_function"
@@ -497,7 +499,9 @@ def test_exported_function_props(
is_exported=True,
)
- result = definition_processor._build_function_props(func_node, resolution)
+ result = definition_processor._build_function_props(
+ func_node, resolution, "proj.module"
+ )
assert result["is_exported"] is True
diff --git a/codebase_rag/tests/test_function_local_definitions.py b/codebase_rag/tests/test_function_local_definitions.py
new file mode 100644
index 000000000..2bd844626
--- /dev/null
+++ b/codebase_rag/tests/test_function_local_definitions.py
@@ -0,0 +1,111 @@
+# (H) Finding #3 from the evals/ harness: methods of a class defined inside a
+# (H) function body (function-local class) were dropped. They are now captured by
+# (H) default (CAPTURE_FUNCTION_LOCAL_DEFINITIONS=True); explicitly disabling the
+# (H) flag restores the historical behaviour of skipping them.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.config import settings
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "localproj"
+
+MODULE_SRC = """class Holder:
+ def make(self) -> object:
+ class Local:
+ def helper(self) -> str:
+ return "x"
+
+ return Local()
+"""
+
+_RelTuple = tuple[str, PropertyValue, str, str, PropertyValue]
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.nodes: dict[tuple[str, PropertyValue], PropertyDict] = {}
+ self.rels: list[_RelTuple] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ uid = properties[cs.NODE_UNIQUE_CONSTRAINTS[label]]
+ self.nodes[(str(label), uid)] = dict(properties)
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append(
+ (
+ str(from_spec[0]),
+ from_spec[2],
+ str(rel_type),
+ str(to_spec[0]),
+ to_spec[2],
+ )
+ )
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _build(tmp_path: Path) -> _Capture:
+ (tmp_path / "m.py").write_text(MODULE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return cap
+
+
+def _local_method_lines(cap: _Capture) -> list[int]:
+ return sorted(
+ int(props[cs.KEY_START_LINE])
+ for (label, _uid), props in cap.nodes.items()
+ if label == cs.NodeLabel.METHOD
+ and props.get(cs.KEY_NAME) == "helper"
+ and props.get(cs.KEY_START_LINE) is not None
+ )
+
+
+class TestFunctionLocalDefinitions:
+ def test_default_captures_local_class_methods(self, tmp_path: Path) -> None:
+ cap = _build(tmp_path)
+ assert _local_method_lines(cap) == [4]
+
+ defines_method_to_helper = [
+ target
+ for (_fl, _fv, rel_type, _tl, target) in cap.rels
+ if rel_type == cs.RelationshipType.DEFINES_METHOD
+ and str(target).endswith(".Local.helper")
+ ]
+ assert len(defines_method_to_helper) == 1, defines_method_to_helper
+
+ def test_flag_off_skips_local_class_methods(
+ self, tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+ ) -> None:
+ monkeypatch.setattr(settings, "CAPTURE_FUNCTION_LOCAL_DEFINITIONS", False)
+ cap = _build(tmp_path)
+ assert _local_method_lines(cap) == []
diff --git a/codebase_rag/tests/test_getattr_dispatch.py b/codebase_rag/tests/test_getattr_dispatch.py
new file mode 100644
index 000000000..eab8f8e39
--- /dev/null
+++ b/codebase_rag/tests/test_getattr_dispatch.py
@@ -0,0 +1,101 @@
+# (H) L3 finding from the evals/ harness: JavaTypeResolverMixin._find_registry_entries_under
+# (H) does `finder = getattr(self.function_registry, cs.METHOD_FIND_WITH_PREFIX, None)` then
+# (H) calls finder(...). The call dispatches to FunctionRegistryTrie.find_with_prefix at
+# (H) runtime. Resolving it needs getattr(recv, name) modelled as recv., where the
+# (H) name argument is a string literal or a module constant resolved to its string value.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+FILES = {
+ "pkg/__init__.py": "",
+ "pkg/names.py": 'METHOD_DO = "do"\n',
+ "pkg/helper.py": (
+ "class Helper:\n def do(self, value):\n return value\n"
+ ),
+ "pkg/worker.py": (
+ "from . import names\n"
+ "from .helper import Helper\n\n\n"
+ "class Worker:\n"
+ " def __init__(self) -> None:\n"
+ " self._helper = Helper()\n\n"
+ " def via_constant(self, value):\n"
+ " fn = getattr(self._helper, names.METHOD_DO, None)\n"
+ " if callable(fn):\n"
+ " return fn(value)\n"
+ " return None\n\n"
+ " def via_literal(self, value):\n"
+ ' fn = getattr(self._helper, "do", None)\n'
+ " return fn(value)\n"
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestGetattrDispatch:
+ def test_getattr_with_constant_name_resolves(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.worker.Worker.via_constant",
+ "proj.pkg.helper.Helper.do",
+ ) in calls, calls
+
+ def test_getattr_with_string_literal_resolves(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.worker.Worker.via_literal",
+ "proj.pkg.helper.Helper.do",
+ ) in calls, calls
diff --git a/codebase_rag/tests/test_github_issues_integration.py b/codebase_rag/tests/test_github_issues_integration.py
index 2b6bc081f..423945657 100644
--- a/codebase_rag/tests/test_github_issues_integration.py
+++ b/codebase_rag/tests/test_github_issues_integration.py
@@ -1,7 +1,10 @@
import os
from unittest.mock import patch
+import pytest
+
from codebase_rag.config import AppConfig
+from codebase_rag.constants import GoogleProviderType
class TestGitHubIssuesIntegration:
@@ -142,9 +145,6 @@ def test_openai_compatible_endpoints(self) -> None:
assert orchestrator.endpoint == "https://api.together.xyz/v1"
def test_vertex_ai_enterprise_scenario(self) -> None:
- """
- Test enterprise Vertex AI configuration scenario.
- """
env_content = {
"ORCHESTRATOR_PROVIDER": "google",
"ORCHESTRATOR_MODEL": "gemini-2.5-pro",
@@ -162,9 +162,63 @@ def test_vertex_ai_enterprise_scenario(self) -> None:
assert orchestrator.model_id == "gemini-2.5-pro"
assert orchestrator.project_id == "my-enterprise-project"
assert orchestrator.region == "us-central1"
- assert orchestrator.provider_type == "vertex"
+ assert orchestrator.provider_type == GoogleProviderType.VERTEX
assert orchestrator.service_account_file == "/path/to/service-account.json"
+ def test_vertex_ai_skips_api_key_validation(self) -> None:
+ env_content = {
+ "ORCHESTRATOR_PROVIDER": "google",
+ "ORCHESTRATOR_MODEL": "gemini-2.5-pro",
+ "ORCHESTRATOR_PROJECT_ID": "my-project",
+ "ORCHESTRATOR_REGION": "us-central1",
+ "ORCHESTRATOR_PROVIDER_TYPE": "vertex",
+ "ORCHESTRATOR_SERVICE_ACCOUNT_FILE": "/path/to/sa.json",
+ "CYPHER_PROVIDER": "google",
+ "CYPHER_MODEL": "gemini-2.5-flash",
+ "CYPHER_PROJECT_ID": "my-project",
+ "CYPHER_REGION": "us-central1",
+ "CYPHER_PROVIDER_TYPE": "vertex",
+ "CYPHER_SERVICE_ACCOUNT_FILE": "/path/to/sa.json",
+ }
+
+ with patch.dict(os.environ, env_content):
+ config = AppConfig()
+
+ orchestrator = config.active_orchestrator_config
+ orchestrator.validate_api_key("orchestrator")
+
+ cypher = config.active_cypher_config
+ cypher.validate_api_key("cypher")
+
+ def test_vertex_ai_with_google_api_key_env_does_not_error(self) -> None:
+ env_content = {
+ "ORCHESTRATOR_PROVIDER": "google",
+ "ORCHESTRATOR_MODEL": "gemini-2.5-pro",
+ "ORCHESTRATOR_PROJECT_ID": "my-project",
+ "ORCHESTRATOR_PROVIDER_TYPE": "vertex",
+ "ORCHESTRATOR_SERVICE_ACCOUNT_FILE": "/path/to/sa.json",
+ "GOOGLE_API_KEY": "stray-key-from-env",
+ }
+
+ with patch.dict(os.environ, env_content):
+ config = AppConfig()
+ orchestrator = config.active_orchestrator_config
+ orchestrator.validate_api_key("orchestrator")
+
+ def test_google_gla_without_api_key_raises(self) -> None:
+ env_content = {
+ "ORCHESTRATOR_PROVIDER": "google",
+ "ORCHESTRATOR_MODEL": "gemini-2.5-pro",
+ "ORCHESTRATOR_PROVIDER_TYPE": "gla",
+ "ORCHESTRATOR_API_KEY": "",
+ }
+
+ with patch.dict(os.environ, env_content):
+ config = AppConfig()
+ orchestrator = config.active_orchestrator_config
+ with pytest.raises(ValueError, match="API Key Missing"):
+ orchestrator.validate_api_key("orchestrator")
+
def test_reasoning_model_thinking_budget(self) -> None:
"""
Test configuration for reasoning models with thinking budget.
diff --git a/codebase_rag/tests/test_go_containment_oracle.py b/codebase_rag/tests/test_go_containment_oracle.py
new file mode 100644
index 000000000..f801132ed
--- /dev/null
+++ b/codebase_rag/tests/test_go_containment_oracle.py
@@ -0,0 +1,67 @@
+# (H) Covers Go containment-edge validation: cgr's DEFINES (Module->top-level
+# (H) func/type) and DEFINES_METHOD (struct Class->receiver method) edges are
+# (H) graded against the independent go/ast oracle (evals/oracles/go_ast.go),
+# (H) joined on (kind, file, line) endpoints. The sample exercises a same-file
+# (H) method and a cross-file method (receiver type declared in another file).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_go_graph
+from evals.oracles import go_available, run_go_oracle
+from evals.score import score_edge_types
+
+GO_TYPES = """\
+package demo
+
+type Shape interface { Area() float64 }
+
+type Point struct{ X int }
+
+func (p Point) Area() float64 { return 1.0 }
+"""
+
+GO_MORE = """\
+package demo
+
+func Free(a int) int { return a + 1 }
+
+func (p Point) Scale(k int) int { return p.X * k }
+"""
+
+
+def _require_go() -> None:
+ if not go_available():
+ pytest.skip("go toolchain not available")
+ if cs.SupportedLanguage.GO not in load_parsers()[0]:
+ pytest.skip("go parser not available")
+
+
+def test_cgr_matches_go_oracle_on_containment_edges(tmp_path: Path) -> None:
+ _require_go()
+ project = tmp_path / "go_edge_test"
+ project.mkdir()
+ (project / "types.go").write_text(GO_TYPES, encoding="utf-8")
+ (project / "more.go").write_text(GO_MORE, encoding="utf-8")
+
+ cgr = extract_cgr_go_graph(project, project.name)
+ oracle = run_go_oracle(project)
+
+ result = score_edge_types(cgr, oracle, ec.SCORED_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in (
+ cs.RelationshipType.DEFINES.value,
+ cs.RelationshipType.DEFINES_METHOD.value,
+ ):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (
+ label,
+ row,
+ result.diff,
+ )
diff --git a/codebase_rag/tests/test_go_receiver_methods.py b/codebase_rag/tests/test_go_receiver_methods.py
new file mode 100644
index 000000000..d5ebd4cc3
--- /dev/null
+++ b/codebase_rag/tests/test_go_receiver_methods.py
@@ -0,0 +1,153 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag.constants import (
+ KEY_QUALIFIED_NAME,
+ NodeLabel,
+ RelationshipType,
+)
+from codebase_rag.tests.conftest import (
+ create_and_run_updater,
+ get_nodes,
+ get_relationships,
+)
+
+
+@pytest.fixture
+def go_methods_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "go_methods_test"
+ project_path.mkdir()
+ (project_path / "go.mod").write_text(
+ encoding="utf-8", data="module go_methods_test\n\ngo 1.22\n"
+ )
+ (project_path / "shapes.go").write_text(
+ encoding="utf-8",
+ data="""package shapes
+
+type Point struct {
+\tX int
+\tY int
+}
+
+type Celsius float64
+
+func (p Point) Area() float64 {
+\treturn 0.0
+}
+
+func (p *Point) Scale(f float64) {
+\tp.X = p.X * int(f)
+}
+
+func (c Celsius) ToFahrenheit() float64 {
+\treturn float64(c)*9/5 + 32
+}
+
+func NewPoint(x int, y int) Point {
+\treturn Point{X: x, Y: y}
+}
+""",
+ )
+ return project_path
+
+
+def _method_qns(mock_ingestor: MagicMock) -> set[str]:
+ return {
+ str(node[0][1].get(KEY_QUALIFIED_NAME))
+ for node in get_nodes(mock_ingestor, NodeLabel.METHOD)
+ }
+
+
+def test_go_value_receiver_method_is_method_node(
+ go_methods_project: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(go_methods_project, mock_ingestor, skip_if_missing="go")
+ project = go_methods_project.name
+ assert f"{project}.shapes.Point.Area" in _method_qns(mock_ingestor)
+
+
+def test_go_pointer_receiver_method_is_method_node(
+ go_methods_project: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(go_methods_project, mock_ingestor, skip_if_missing="go")
+ project = go_methods_project.name
+ assert f"{project}.shapes.Point.Scale" in _method_qns(mock_ingestor)
+
+
+def test_go_defined_type_receiver_method_is_method_node(
+ go_methods_project: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(go_methods_project, mock_ingestor, skip_if_missing="go")
+ project = go_methods_project.name
+ assert f"{project}.shapes.Celsius.ToFahrenheit" in _method_qns(mock_ingestor)
+
+
+def test_go_free_function_not_a_method(
+ go_methods_project: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(go_methods_project, mock_ingestor, skip_if_missing="go")
+ project = go_methods_project.name
+ function_qns = {
+ str(node[0][1].get(KEY_QUALIFIED_NAME))
+ for node in get_nodes(mock_ingestor, NodeLabel.FUNCTION)
+ }
+ assert f"{project}.shapes.NewPoint" in function_qns
+ # (H) A receiver method must not also be emitted as a plain Function.
+ assert f"{project}.shapes.Area" not in function_qns
+ assert f"{project}.shapes.Point.Area" not in function_qns
+
+
+def test_go_method_defined_by_receiver_type(
+ go_methods_project: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(go_methods_project, mock_ingestor, skip_if_missing="go")
+ project = go_methods_project.name
+ defines_method = get_relationships(
+ mock_ingestor, RelationshipType.DEFINES_METHOD.value
+ )
+ pairs = {(call[0][0][2], call[0][2][2]) for call in defines_method}
+ assert (f"{project}.shapes.Point", f"{project}.shapes.Point.Area") in pairs
+ assert (
+ f"{project}.shapes.Celsius",
+ f"{project}.shapes.Celsius.ToFahrenheit",
+ ) in pairs
+
+
+@pytest.fixture
+def go_crossfile_project(temp_repo: Path) -> Path:
+ # (H) Same Go package split across two files: the receiver type lives in
+ # (H) types.go, a method on it lives in ops.go. A Go package spans every
+ # (H) file in its directory, so the method must bind to the type's node.
+ project_path = temp_repo / "go_xfile_test"
+ project_path.mkdir()
+ (project_path / "go.mod").write_text(
+ encoding="utf-8", data="module go_xfile_test\n\ngo 1.22\n"
+ )
+ (project_path / "types.go").write_text(
+ encoding="utf-8",
+ data="package shapes\n\ntype Point struct {\n\tX int\n}\n",
+ )
+ (project_path / "ops.go").write_text(
+ encoding="utf-8",
+ data="package shapes\n\nfunc (p Point) Scale(k int) int {\n\treturn p.X * k\n}\n",
+ )
+ return project_path
+
+
+def test_go_crossfile_method_binds_to_declaring_type(
+ go_crossfile_project: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(go_crossfile_project, mock_ingestor, skip_if_missing="go")
+ project = go_crossfile_project.name
+ # (H) Point is declared in types.go, so its Class node and the method's qn
+ # (H) are anchored to the types module, not the ops module that holds Scale.
+ assert f"{project}.types.Point.Scale" in _method_qns(mock_ingestor)
+ defines_method = get_relationships(
+ mock_ingestor, RelationshipType.DEFINES_METHOD.value
+ )
+ pairs = {(call[0][0][2], call[0][2][2]) for call in defines_method}
+ assert (f"{project}.types.Point", f"{project}.types.Point.Scale") in pairs
diff --git a/codebase_rag/tests/test_go_span_oracle.py b/codebase_rag/tests/test_go_span_oracle.py
new file mode 100644
index 000000000..aafd3a334
--- /dev/null
+++ b/codebase_rag/tests/test_go_span_oracle.py
@@ -0,0 +1,72 @@
+# (H) Covers Go node SPAN (end_line) validation: cgr's end_line for each node is
+# (H) graded against the go/ast oracle (which emits each declaration's last-token
+# (H) line), joined on (kind, file, start). Exercises a multi-line struct, a
+# (H) grouped `type (...)` block, an interface, and a multi-line method body.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_go_graph
+from evals.oracles import go_available, run_go_oracle
+from evals.score import score_span
+
+GO_SRC = """\
+package demo
+
+type Shape interface {
+ Area() float64
+ Name() string
+}
+
+type Point struct {
+ X int
+ Y int
+}
+
+type (
+ Meters int
+ Label string
+)
+
+func (p Point) Area(
+ scale float64,
+) float64 {
+ return float64(p.X) * scale
+}
+
+func Free(a int) int {
+ return a + 1
+}
+"""
+
+
+def _require_go() -> None:
+ if not go_available():
+ pytest.skip("go toolchain not available")
+ if cs.SupportedLanguage.GO not in load_parsers()[0]:
+ pytest.skip("go parser not available")
+
+
+def test_cgr_matches_go_oracle_on_node_spans(tmp_path: Path) -> None:
+ _require_go()
+ project = tmp_path / "go_span_test"
+ project.mkdir()
+ (project / "demo.go").write_text(GO_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_go_graph(project, project.name)
+ oracle = run_go_oracle(project)
+
+ result = score_span(cgr, oracle, ec.GO_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ aggregate = by_label.get(ec.AGGREGATE_LABEL)
+ assert aggregate is not None, (by_label, result.diff)
+ assert aggregate["precision"] == 1.0 and aggregate["recall"] == 1.0, (
+ aggregate,
+ result.diff,
+ )
+ assert aggregate["tp"] >= 5, aggregate
diff --git a/codebase_rag/tests/test_go_structure_oracle.py b/codebase_rag/tests/test_go_structure_oracle.py
new file mode 100644
index 000000000..1035cb497
--- /dev/null
+++ b/codebase_rag/tests/test_go_structure_oracle.py
@@ -0,0 +1,90 @@
+# (H) Covers the Go structure oracle harness (evals/oracles/go_ast.go +
+# (H) evals/go_l1.py): the go/ast oracle is authoritative ground truth, and cgr's
+# (H) captured Go nodes are graded against it on (kind, file, start_line).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals.cgr_graph import extract_cgr_go_nodes
+from evals.oracles import go_available, run_go_oracle
+from evals.score import score_node_kinds
+from evals.types_defs import GraphData
+
+GO_SRC = """package shapes
+
+type Point struct {
+\tX int
+\tY int
+}
+
+type Shape interface {
+\tArea() float64
+}
+
+type Celsius float64
+
+func NewPoint(x int, y int) Point {
+\treturn Point{X: x, Y: y}
+}
+
+func (p Point) Area() float64 {
+\treturn 0.0
+}
+"""
+
+
+def _require_go() -> None:
+ if not go_available():
+ pytest.skip("go toolchain not available")
+ if cs.SupportedLanguage.GO not in load_parsers()[0]:
+ pytest.skip("go parser not available")
+
+
+def _go_project(tmp_path: Path) -> Path:
+ project = tmp_path / "shapes_mod"
+ project.mkdir()
+ (project / "go.mod").write_text("module shapes_mod\n\ngo 1.22\n", encoding="utf-8")
+ (project / "shapes.go").write_text(GO_SRC, encoding="utf-8")
+ return project
+
+
+def _names(nodes: dict, kind: cs.NodeLabel) -> set[str]:
+ return {node.name for key, node in nodes.items() if key.kind == kind.value}
+
+
+def test_oracle_labels_go_declarations(tmp_path: Path) -> None:
+ _require_go()
+ oracle = run_go_oracle(_go_project(tmp_path)).nodes
+ assert _names(oracle, cs.NodeLabel.CLASS) == {"Point"}
+ assert _names(oracle, cs.NodeLabel.INTERFACE) == {"Shape"}
+ assert _names(oracle, cs.NodeLabel.TYPE) == {"Celsius"}
+ assert _names(oracle, cs.NodeLabel.FUNCTION) == {"NewPoint"}
+ # (H) go/ast knows Area has a receiver, so it is a Method, not a Function.
+ assert _names(oracle, cs.NodeLabel.METHOD) == {"Area"}
+
+
+def test_cgr_matches_oracle_on_type_declarations(tmp_path: Path) -> None:
+ _require_go()
+ project = _go_project(tmp_path)
+ cgr = GraphData(
+ nodes=extract_cgr_go_nodes(project, project.name), edges=set(), name_edges=set()
+ )
+ oracle = run_go_oracle(project)
+
+ result = score_node_kinds(
+ cgr,
+ oracle,
+ (cs.NodeLabel.CLASS, cs.NodeLabel.INTERFACE, cs.NodeLabel.TYPE),
+ )
+ by_label = {row["label"]: row for row in result.rows}
+ for label in (
+ cs.NodeLabel.CLASS.value,
+ cs.NodeLabel.INTERFACE.value,
+ cs.NodeLabel.TYPE.value,
+ ):
+ assert by_label[label]["recall"] == 1.0, (label, by_label[label])
+ assert by_label[label]["precision"] == 1.0, (label, by_label[label])
diff --git a/codebase_rag/tests/test_go_type_declarations.py b/codebase_rag/tests/test_go_type_declarations.py
new file mode 100644
index 000000000..ee6894df3
--- /dev/null
+++ b/codebase_rag/tests/test_go_type_declarations.py
@@ -0,0 +1,94 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag.constants import KEY_NAME, NodeLabel
+from codebase_rag.tests.conftest import create_and_run_updater, get_nodes
+
+
+@pytest.fixture
+def go_types_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "go_types_test"
+ project_path.mkdir()
+ (project_path / "go.mod").write_text(
+ encoding="utf-8", data="module go_types_test\n\ngo 1.22\n"
+ )
+ (project_path / "shapes.go").write_text(
+ encoding="utf-8",
+ data="""package shapes
+
+type Point struct {
+\tX int
+\tY int
+}
+
+type Shape interface {
+\tArea() float64
+}
+
+type Celsius float64
+
+type (
+\tWidget struct {
+\t\tID int
+\t}
+\tDrawable interface {
+\t\tDraw() string
+\t}
+\tFahrenheit float64
+)
+
+func NewPoint(x int, y int) Point {
+\treturn Point{X: x, Y: y}
+}
+""",
+ )
+ return project_path
+
+
+def _names(mock_ingestor: MagicMock, label: NodeLabel) -> set[str]:
+ return {
+ str(node[0][1].get(KEY_NAME))
+ for node in get_nodes(mock_ingestor, label)
+ if str(node[0][1].get(KEY_NAME))
+ }
+
+
+def test_go_struct_captured_as_class(
+ go_types_project: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(go_types_project, mock_ingestor, skip_if_missing="go")
+ classes = _names(mock_ingestor, NodeLabel.CLASS)
+ assert "Point" in classes, f"Go struct Point missing from Class nodes: {classes}"
+ assert "Widget" in classes, (
+ f"Grouped Go struct Widget missing from Class nodes: {classes}"
+ )
+
+
+def test_go_interface_captured_as_interface(
+ go_types_project: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(go_types_project, mock_ingestor, skip_if_missing="go")
+ interfaces = _names(mock_ingestor, NodeLabel.INTERFACE)
+ assert "Shape" in interfaces, (
+ f"Go interface Shape missing from Interface nodes: {interfaces}"
+ )
+ assert "Drawable" in interfaces, (
+ f"Grouped Go interface Drawable missing from Interface nodes: {interfaces}"
+ )
+
+
+def test_go_type_alias_captured_as_type(
+ go_types_project: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(go_types_project, mock_ingestor, skip_if_missing="go")
+ types = _names(mock_ingestor, NodeLabel.TYPE)
+ assert "Celsius" in types, (
+ f"Go defined type Celsius missing from Type nodes: {types}"
+ )
+ assert "Fahrenheit" in types, (
+ f"Grouped Go defined type Fahrenheit missing from Type nodes: {types}"
+ )
diff --git a/codebase_rag/tests/test_graph_service.py b/codebase_rag/tests/test_graph_service.py
index c31b30741..76e5a6ed2 100644
--- a/codebase_rag/tests/test_graph_service.py
+++ b/codebase_rag/tests/test_graph_service.py
@@ -5,7 +5,13 @@
import pytest
from codebase_rag.constants import NODE_UNIQUE_CONSTRAINTS
-from codebase_rag.cypher_queries import wrap_with_unwind
+from codebase_rag.cypher_queries import (
+ build_create_node_query,
+ build_create_relationship_query,
+ build_merge_node_query,
+ build_merge_relationship_query,
+ wrap_with_unwind,
+)
from codebase_rag.services.graph_service import MemgraphIngestor
@@ -38,13 +44,63 @@ def test_init_creates_empty_buffers(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
assert ingestor.node_buffer == []
- assert ingestor.relationship_buffer == []
+ assert ingestor._rel_count == 0
def test_init_conn_is_none(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
assert ingestor.conn is None
+ def test_init_stores_auth_credentials(self) -> None:
+ ingestor = MemgraphIngestor(
+ host="localhost", port=7687, username="user", password="pass"
+ )
+
+ assert ingestor._username == "user"
+ assert ingestor._password == "pass"
+
+ def test_init_defaults_auth_to_none(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687)
+
+ assert ingestor._username is None
+ assert ingestor._password is None
+
+ def test_init_raises_for_username_without_password(self) -> None:
+ with pytest.raises(ValueError, match="Both username and password"):
+ MemgraphIngestor(host="localhost", port=7687, username="user")
+
+ def test_init_raises_for_password_without_username(self) -> None:
+ with pytest.raises(ValueError, match="Both username and password"):
+ MemgraphIngestor(host="localhost", port=7687, password="pass")
+
+ def test_init_normalizes_empty_strings_to_none(self) -> None:
+ ingestor = MemgraphIngestor(
+ host="localhost", port=7687, username="", password=""
+ )
+
+ assert ingestor._username is None
+ assert ingestor._password is None
+
+ def test_init_normalizes_whitespace_only_to_none(self) -> None:
+ ingestor = MemgraphIngestor(
+ host="localhost", port=7687, username=" ", password=" "
+ )
+
+ assert ingestor._username is None
+ assert ingestor._password is None
+
+ def test_init_strips_whitespace_from_credentials(self) -> None:
+ ingestor = MemgraphIngestor(
+ host="localhost", port=7687, username=" user ", password=" pass "
+ )
+
+ assert ingestor._username == "user"
+ assert ingestor._password == "pass"
+
+ def test_init_raises_for_empty_password_with_valid_username(self) -> None:
+ with pytest.raises(ValueError, match="Both username and password"):
+ MemgraphIngestor(host="localhost", port=7687, username="user", password="")
+
class TestContextManager:
def test_enter_connects_to_memgraph(self) -> None:
@@ -60,12 +116,36 @@ def test_enter_connects_to_memgraph(self) -> None:
assert mock_conn.autocommit is True
assert result is ingestor
+ def test_enter_passes_auth_when_provided(self) -> None:
+ with patch("codebase_rag.services.graph_service.mgclient") as mock_mgclient:
+ mock_conn = MagicMock()
+ mock_mgclient.connect.return_value = mock_conn
+
+ ingestor = MemgraphIngestor(
+ host="testhost", port=1234, username="user", password="pass"
+ )
+ ingestor.__enter__()
+
+ mock_mgclient.connect.assert_called_once_with(
+ host="testhost", port=1234, username="user", password="pass"
+ )
+
+ def test_enter_omits_auth_when_not_provided(self) -> None:
+ with patch("codebase_rag.services.graph_service.mgclient") as mock_mgclient:
+ mock_conn = MagicMock()
+ mock_mgclient.connect.return_value = mock_conn
+
+ ingestor = MemgraphIngestor(host="testhost", port=1234)
+ ingestor.__enter__()
+
+ mock_mgclient.connect.assert_called_once_with(host="testhost", port=1234)
+
def test_exit_flushes_and_closes_connection(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
mock_conn = MagicMock()
ingestor.conn = mock_conn
- with patch.object(ingestor, "flush_all") as mock_flush:
+ with patch.object(MemgraphIngestor, "flush_all") as mock_flush:
ingestor.__exit__(None, None, None)
mock_flush.assert_called_once()
@@ -76,7 +156,7 @@ def test_exit_logs_error_on_exception(self) -> None:
mock_conn = MagicMock()
ingestor.conn = mock_conn
- with patch.object(ingestor, "flush_all"):
+ with patch.object(MemgraphIngestor, "flush_all"):
ingestor.__exit__(ValueError, ValueError("test error"), None)
mock_conn.close.assert_called_once()
@@ -85,7 +165,7 @@ def test_exit_handles_none_connection(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
ingestor.conn = None
- with patch.object(ingestor, "flush_all"):
+ with patch.object(MemgraphIngestor, "flush_all"):
ingestor.__exit__(None, None, None)
@@ -206,19 +286,13 @@ def test_suppresses_already_exists_errors_in_logs(self) -> None:
ingestor._execute_query("CREATE CONSTRAINT")
-class TestExecuteBatch:
- def test_returns_early_when_not_connected(self) -> None:
- ingestor = MemgraphIngestor(host="localhost", port=7687)
- ingestor.conn = None
-
- ingestor._execute_batch("MERGE (n:Test)", [{"id": 1}])
-
+class TestExecuteBatchOn:
def test_returns_early_when_params_empty(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
mock_conn = MagicMock()
ingestor.conn = mock_conn
- ingestor._execute_batch("MERGE (n:Test)", [])
+ ingestor._execute_batch_on(mock_conn, "MERGE (n:Test)", [])
mock_conn.cursor.assert_not_called()
@@ -229,7 +303,9 @@ def test_wraps_query_with_unwind(self) -> None:
mock_conn.cursor.return_value = mock_cursor
ingestor.conn = mock_conn
- ingestor._execute_batch("MERGE (n:Test {id: row.id})", [{"id": 1}, {"id": 2}])
+ ingestor._execute_batch_on(
+ mock_conn, "MERGE (n:Test {id: row.id})", [{"id": 1}, {"id": 2}]
+ )
call_args = mock_cursor.execute.call_args[0]
assert call_args[0] == wrap_with_unwind("MERGE (n:Test {id: row.id})")
@@ -242,7 +318,7 @@ def test_closes_cursor_on_success(self) -> None:
mock_conn.cursor.return_value = mock_cursor
ingestor.conn = mock_conn
- ingestor._execute_batch("MERGE (n:Test)", [{"id": 1}])
+ ingestor._execute_batch_on(mock_conn, "MERGE (n:Test)", [{"id": 1}])
mock_cursor.close.assert_called_once()
@@ -251,7 +327,7 @@ class TestCleanDatabase:
def test_executes_delete_query(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
- with patch.object(ingestor, "_execute_query") as mock_execute:
+ with patch.object(MemgraphIngestor, "_execute_query") as mock_execute:
ingestor.clean_database()
mock_execute.assert_called_once_with("MATCH (n) DETACH DELETE n;")
@@ -265,7 +341,9 @@ def test_creates_constraint_for_each_node_type(self) -> None:
def capture_query(query: str) -> None:
executed_queries.append(query)
- with patch.object(ingestor, "_execute_query", side_effect=capture_query):
+ with patch.object(
+ MemgraphIngestor, "_execute_query", side_effect=capture_query
+ ):
ingestor.ensure_constraints()
for label, prop in NODE_UNIQUE_CONSTRAINTS.items():
@@ -282,7 +360,9 @@ def fail_then_succeed(query: str) -> None:
if call_count == 1:
raise RuntimeError("Constraint already exists")
- with patch.object(ingestor, "_execute_query", side_effect=fail_then_succeed):
+ with patch.object(
+ MemgraphIngestor, "_execute_query", side_effect=fail_then_succeed
+ ):
ingestor.ensure_constraints()
expected_queries = len(NODE_UNIQUE_CONSTRAINTS) * 2
@@ -384,7 +464,7 @@ def mock_fetch_all(query: str, params: dict | None = None) -> list[dict]:
return [{"node_id": 1}, {"node_id": 2}, {"node_id": 3}]
return [{"from_id": 1, "to_id": 2}]
- with patch.object(ingestor, "fetch_all", side_effect=mock_fetch_all):
+ with patch.object(MemgraphIngestor, "fetch_all", side_effect=mock_fetch_all):
result = ingestor.export_graph_to_dict()
assert result["metadata"]["total_nodes"] == 3
@@ -396,8 +476,8 @@ def test_calls_flush_nodes_and_flush_relationships(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
with (
- patch.object(ingestor, "flush_nodes") as mock_nodes,
- patch.object(ingestor, "flush_relationships") as mock_rels,
+ patch.object(MemgraphIngestor, "flush_nodes") as mock_nodes,
+ patch.object(MemgraphIngestor, "flush_relationships") as mock_rels,
):
ingestor.flush_all()
@@ -407,20 +487,36 @@ def test_calls_flush_nodes_and_flush_relationships(self) -> None:
class TestFetchAllAndExecuteWrite:
def test_fetch_all_delegates_to_execute_query(self) -> None:
+ from codebase_rag.config import settings
+
ingestor = MemgraphIngestor(host="localhost", port=7687)
with patch.object(
- ingestor, "_execute_query", return_value=[{"n": "result"}]
+ MemgraphIngestor, "_execute_query", return_value=[{"n": "result"}]
) as mock_exec:
result = ingestor.fetch_all("MATCH (n) RETURN n", {"limit": 10})
- mock_exec.assert_called_once_with("MATCH (n) RETURN n", {"limit": 10})
+ expected_query = (
+ f"MATCH (n) RETURN n QUERY MEMORY LIMIT "
+ f"{settings.QUERY_MEMORY_LIMIT_MB} MB;"
+ )
+ mock_exec.assert_called_once_with(expected_query, {"limit": 10})
assert result == [{"n": "result"}]
+ def test_fetch_all_preserves_existing_memory_limit(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687)
+ query_with_hint = "MATCH (n) RETURN n QUERY MEMORY LIMIT 512 MB;"
+
+ with patch.object(
+ MemgraphIngestor, "_execute_query", return_value=[]
+ ) as mock_exec:
+ ingestor.fetch_all(query_with_hint)
+ mock_exec.assert_called_once_with(query_with_hint, None)
+
def test_execute_write_delegates_to_execute_query(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
- with patch.object(ingestor, "_execute_query") as mock_exec:
+ with patch.object(MemgraphIngestor, "_execute_query") as mock_exec:
ingestor.execute_write("CREATE (n:Test)", {"name": "test"})
mock_exec.assert_called_once_with("CREATE (n:Test)", {"name": "test"})
@@ -434,3 +530,187 @@ def test_returns_iso_format_timestamp(self) -> None:
assert "T" in result
assert len(result) > 10
+
+
+class TestCreateMode:
+ def test_default_use_merge_is_true(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687)
+ assert ingestor._use_merge is True
+
+ def test_use_merge_false(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687, use_merge=False)
+ assert ingestor._use_merge is False
+
+ def test_flush_nodes_uses_merge_query_by_default(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687, batch_size=10)
+ mock_conn = MagicMock()
+ mock_cursor = MagicMock()
+ mock_conn.cursor.return_value = mock_cursor
+ ingestor.conn = mock_conn
+
+ ingestor.node_buffer.append(("File", {"path": "/test.py", "name": "test"}))
+ ingestor.flush_nodes()
+
+ call_args = mock_cursor.execute.call_args[0][0]
+ assert "MERGE" in call_args
+ assert "CREATE" not in call_args.split("MERGE")[0]
+
+ def test_flush_nodes_uses_create_query_when_merge_disabled(self) -> None:
+ ingestor = MemgraphIngestor(
+ host="localhost", port=7687, batch_size=10, use_merge=False
+ )
+ mock_conn = MagicMock()
+ mock_cursor = MagicMock()
+ mock_conn.cursor.return_value = mock_cursor
+ ingestor.conn = mock_conn
+
+ ingestor.node_buffer.append(("File", {"path": "/test.py", "name": "test"}))
+ ingestor.flush_nodes()
+
+ call_args = mock_cursor.execute.call_args[0][0]
+ assert "CREATE" in call_args
+ assert "MERGE" not in call_args
+
+ def test_flush_relationships_uses_merge_query_by_default(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687, batch_size=10)
+ mock_conn = MagicMock()
+ mock_cursor = MagicMock()
+ mock_conn.cursor.return_value = mock_cursor
+ mock_cursor.description = [MagicMock(name="created")]
+ mock_cursor.description[0].name = "created"
+ mock_cursor.fetchall.return_value = [(1,)]
+ ingestor.conn = mock_conn
+
+ ingestor.ensure_relationship_batch(
+ ("File", "path", "/a.py"), "IMPORTS", ("File", "path", "/b.py")
+ )
+ ingestor.flush_relationships()
+
+ call_args = mock_cursor.execute.call_args[0][0]
+ assert "MERGE" in call_args
+
+ def test_flush_relationships_uses_create_query_when_merge_disabled(self) -> None:
+ ingestor = MemgraphIngestor(
+ host="localhost", port=7687, batch_size=10, use_merge=False
+ )
+ mock_conn = MagicMock()
+ mock_cursor = MagicMock()
+ mock_conn.cursor.return_value = mock_cursor
+ mock_cursor.description = [MagicMock(name="created")]
+ mock_cursor.description[0].name = "created"
+ mock_cursor.fetchall.return_value = [(1,)]
+ ingestor.conn = mock_conn
+
+ ingestor.ensure_relationship_batch(
+ ("File", "path", "/a.py"), "IMPORTS", ("File", "path", "/b.py")
+ )
+ ingestor.flush_relationships()
+
+ call_args = mock_cursor.execute.call_args[0][0]
+ assert "CREATE" in call_args
+ assert "MERGE" not in call_args
+
+
+class TestPreGroupedRelBuffer:
+ def test_rel_groups_populated_on_ensure(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687)
+ ingestor.ensure_relationship_batch(
+ ("File", "path", "/a.py"), "IMPORTS", ("File", "path", "/b.py")
+ )
+ assert len(ingestor._rel_groups) == 1
+
+ def test_rel_groups_groups_by_pattern(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687)
+ ingestor.ensure_relationship_batch(
+ ("File", "path", "/a.py"), "IMPORTS", ("File", "path", "/b.py")
+ )
+ ingestor.ensure_relationship_batch(
+ ("File", "path", "/a.py"), "IMPORTS", ("File", "path", "/c.py")
+ )
+ ingestor.ensure_relationship_batch(
+ ("Module", "qualified_name", "mod_a"),
+ "DEFINES",
+ ("Function", "qualified_name", "func_b"),
+ )
+ assert len(ingestor._rel_groups) == 2
+ pattern = ("File", "path", "IMPORTS", "File", "path")
+ assert len(ingestor._rel_groups[pattern]) == 2
+
+ def test_rel_groups_cleared_after_flush(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687)
+ mock_conn = MagicMock()
+ mock_cursor = MagicMock()
+ mock_conn.cursor.return_value = mock_cursor
+ mock_cursor.description = [MagicMock(name="created")]
+ mock_cursor.description[0].name = "created"
+ mock_cursor.fetchall.return_value = [(1,)]
+ ingestor.conn = mock_conn
+
+ ingestor.ensure_relationship_batch(
+ ("File", "path", "/a.py"), "IMPORTS", ("File", "path", "/b.py")
+ )
+ ingestor.flush_relationships()
+
+ assert len(ingestor._rel_groups) == 0
+
+ def test_rel_groups_empty_on_init(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687)
+ assert len(ingestor._rel_groups) == 0
+
+ def test_rel_groups_correct_batch_row_values(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687)
+ ingestor.ensure_relationship_batch(
+ ("File", "path", "/a.py"),
+ "IMPORTS",
+ ("File", "path", "/b.py"),
+ {"weight": 1},
+ )
+ pattern = ("File", "path", "IMPORTS", "File", "path")
+ rows = ingestor._rel_groups[pattern]
+ assert len(rows) == 1
+ assert rows[0]["from_val"] == "/a.py"
+ assert rows[0]["to_val"] == "/b.py"
+ assert rows[0]["props"] == {"weight": 1}
+
+
+class TestSlots:
+ def test_has_slots(self) -> None:
+ assert hasattr(MemgraphIngestor, "__slots__")
+
+ def test_no_dict(self) -> None:
+ ingestor = MemgraphIngestor(host="localhost", port=7687)
+ assert not hasattr(ingestor, "__dict__")
+
+
+class TestCypherCreateQueries:
+ def test_build_create_node_query(self) -> None:
+ query = build_create_node_query("File", "path")
+ assert "CREATE" in query
+ assert "MERGE" not in query
+ assert "path: row.id" in query
+
+ def test_build_create_relationship_query(self) -> None:
+ query = build_create_relationship_query(
+ "File", "path", "IMPORTS", "File", "path"
+ )
+ assert "CREATE (a)-[r:IMPORTS]->(b)" in query
+ assert "MERGE" not in query
+
+ def test_build_create_relationship_query_with_props(self) -> None:
+ query = build_create_relationship_query(
+ "File", "path", "IMPORTS", "File", "path", has_props=True
+ )
+ assert "SET r += row.props" in query
+ assert "CREATE (a)-[r:IMPORTS]->(b)" in query
+
+ def test_build_merge_node_query_unchanged(self) -> None:
+ query = build_merge_node_query("File", "path")
+ assert "MERGE" in query
+ assert "CREATE" not in query
+
+ def test_build_merge_relationship_query_unchanged(self) -> None:
+ query = build_merge_relationship_query(
+ "File", "path", "IMPORTS", "File", "path"
+ )
+ assert "MERGE" in query
+ assert "CREATE" not in query.replace("MERGE", "")
diff --git a/codebase_rag/tests/test_graph_service_calls_failure_logging.py b/codebase_rag/tests/test_graph_service_calls_failure_logging.py
index 2af717f06..6bb8f2e99 100644
--- a/codebase_rag/tests/test_graph_service_calls_failure_logging.py
+++ b/codebase_rag/tests/test_graph_service_calls_failure_logging.py
@@ -56,8 +56,8 @@ def test_calls_failure_logging_single_batch(
)
with patch.object(
- graph_service,
- "_execute_batch_with_return",
+ MemgraphIngestor,
+ "_execute_batch_with_return_on",
return_value=[{"created": 1}, {"created": 0}, {"created": 0}],
):
graph_service.flush_relationships()
@@ -72,13 +72,6 @@ def test_calls_failure_logging_single_batch(
def test_calls_failure_logging_multiple_batches(
graph_service: MemgraphIngestor, log_messages: list[str]
) -> None:
- """Test that CALLS failures are logged correctly across multiple batches.
-
- This is the critical test case that validates the bug fix:
- - Previously, the code used cumulative totals (total_attempted - total_successful)
- - This would incorrectly report failures for batches after the first one
- - Now it correctly uses batch-specific counts (len(params_list) - batch_successful)
- """
graph_service.ensure_relationship_batch(
("Method", "qualified_name", "project.module.ClassA.methodA()"),
"CALLS",
@@ -104,14 +97,16 @@ def test_calls_failure_logging_multiple_batches(
call_count = 0
def mock_execute_batch(
- query: str, params_list: list[dict[str, Any]]
+ conn: Any, query: str, params_list: list[dict[str, Any]]
) -> list[dict[str, int]]:
nonlocal call_count
call_count += 1
return [{"created": 1}, {"created": 0}]
with patch.object(
- graph_service, "_execute_batch_with_return", side_effect=mock_execute_batch
+ MemgraphIngestor,
+ "_execute_batch_with_return_on",
+ side_effect=mock_execute_batch,
):
graph_service.flush_relationships()
@@ -127,7 +122,6 @@ def mock_execute_batch(
def test_calls_success_no_failure_logging(
graph_service: MemgraphIngestor, log_messages: list[str]
) -> None:
- """Test that successful CALLS don't trigger failure warnings."""
graph_service.ensure_relationship_batch(
("Method", "qualified_name", "project.module.ClassA.methodA()"),
"CALLS",
@@ -140,8 +134,8 @@ def test_calls_success_no_failure_logging(
)
with patch.object(
- graph_service,
- "_execute_batch_with_return",
+ MemgraphIngestor,
+ "_execute_batch_with_return_on",
return_value=[{"created": 1}, {"created": 1}],
):
graph_service.flush_relationships()
@@ -154,7 +148,6 @@ def test_calls_success_no_failure_logging(
def test_non_calls_relationships_no_failure_logging(
graph_service: MemgraphIngestor, log_messages: list[str]
) -> None:
- """Test that failures in non-CALLS relationships don't trigger CALLS-specific logging."""
graph_service.ensure_relationship_batch(
("Module", "qualified_name", "project.moduleA"),
"IMPORTS",
@@ -167,8 +160,8 @@ def test_non_calls_relationships_no_failure_logging(
)
with patch.object(
- graph_service,
- "_execute_batch_with_return",
+ MemgraphIngestor,
+ "_execute_batch_with_return_on",
return_value=[{"created": 1}, {"created": 0}],
):
graph_service.flush_relationships()
diff --git a/codebase_rag/tests/test_graph_updater_embeddings.py b/codebase_rag/tests/test_graph_updater_embeddings.py
new file mode 100644
index 000000000..c88fc54ac
--- /dev/null
+++ b/codebase_rag/tests/test_graph_updater_embeddings.py
@@ -0,0 +1,335 @@
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.services.graph_service import MemgraphIngestor
+from codebase_rag.types_defs import ResultRow
+
+MOCK_EMBEDDING = [0.1] * 768
+
+
+def _fake_embed_batch(snippets: list[str], **_kwargs: object) -> list[list[float]]:
+ return [MOCK_EMBEDDING for _ in snippets]
+
+
+_PATCH_DEPS = patch(
+ "codebase_rag.graph_updater.has_semantic_dependencies", return_value=True
+)
+_PATCH_EMBED_BATCH = patch(
+ "codebase_rag.embedder.embed_code_batch", side_effect=_fake_embed_batch
+)
+_PATCH_STORE_BATCH = patch(
+ "codebase_rag.vector_store.store_embedding_batch", side_effect=lambda pts: len(pts)
+)
+_PATCH_RECONCILE = patch(
+ "codebase_rag.vector_store.verify_stored_ids", side_effect=lambda ids: ids
+)
+
+
+@pytest.fixture
+def query_ingestor() -> MagicMock:
+ mock = MagicMock(spec=MemgraphIngestor)
+ mock.fetch_all = MagicMock(return_value=[])
+ mock.execute_write = MagicMock()
+ return mock
+
+
+@pytest.fixture
+def updater_with_query(temp_repo: Path, query_ingestor: MagicMock) -> GraphUpdater:
+ parsers, queries = load_parsers()
+ return GraphUpdater(
+ ingestor=query_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+
+
+class TestCypherQueryEmbeddingsStructure:
+ def test_contains_starts_with_project_name(self) -> None:
+ assert "STARTS WITH" in cs.CYPHER_QUERY_EMBEDDINGS
+ assert "$project_name" in cs.CYPHER_QUERY_EMBEDDINGS
+
+ def test_returns_required_columns(self) -> None:
+ query = cs.CYPHER_QUERY_EMBEDDINGS.upper()
+ for col in ["NODE_ID", "QUALIFIED_NAME", "START_LINE", "END_LINE", "PATH"]:
+ assert col in query
+
+ def test_dot_concatenation_is_parenthesized(self) -> None:
+ assert "($project_name + '.')" in cs.CYPHER_QUERY_EMBEDDINGS
+
+ def test_no_bare_starts_with_plus(self) -> None:
+ for line in cs.CYPHER_QUERY_EMBEDDINGS.splitlines():
+ stripped = line.strip()
+ if "STARTS WITH" in stripped and "$project_name" in stripped:
+ assert "($project_name" in stripped, (
+ f"$project_name + '.' must be parenthesized in: {stripped!r}"
+ )
+
+
+class TestGenerateSemanticEmbeddings:
+ @_PATCH_DEPS
+ @_PATCH_EMBED_BATCH
+ @_PATCH_STORE_BATCH
+ @_PATCH_RECONCILE
+ def test_passes_project_name_without_trailing_dot(
+ self,
+ _mock_reconcile: MagicMock,
+ _mock_store_batch: MagicMock,
+ _mock_embed_batch: MagicMock,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ ) -> None:
+ query_ingestor.fetch_all.return_value = []
+ updater_with_query._generate_semantic_embeddings()
+
+ params = query_ingestor.fetch_all.call_args[0][1]
+ project_name_param = params["project_name"]
+ assert not project_name_param.endswith("."), (
+ f"project_name should not have trailing dot, got: {project_name_param!r}"
+ )
+
+ @_PATCH_DEPS
+ @_PATCH_EMBED_BATCH
+ @_PATCH_STORE_BATCH
+ @_PATCH_RECONCILE
+ def test_uses_cypher_query_embeddings_constant(
+ self,
+ _mock_reconcile: MagicMock,
+ _mock_store_batch: MagicMock,
+ _mock_embed_batch: MagicMock,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ ) -> None:
+ query_ingestor.fetch_all.return_value = []
+ updater_with_query._generate_semantic_embeddings()
+
+ query_arg = query_ingestor.fetch_all.call_args[0][0]
+ assert query_arg == cs.CYPHER_QUERY_EMBEDDINGS
+
+ @patch("codebase_rag.graph_updater.has_semantic_dependencies", return_value=False)
+ def test_skips_when_no_semantic_dependencies(
+ self,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ ) -> None:
+ updater_with_query._generate_semantic_embeddings()
+ query_ingestor.fetch_all.assert_not_called()
+
+ @_PATCH_DEPS
+ @_PATCH_EMBED_BATCH
+ @_PATCH_STORE_BATCH
+ @_PATCH_RECONCILE
+ def test_returns_early_on_empty_results(
+ self,
+ _mock_reconcile: MagicMock,
+ mock_store_batch: MagicMock,
+ _mock_embed_batch: MagicMock,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ ) -> None:
+ query_ingestor.fetch_all.return_value = []
+ updater_with_query._generate_semantic_embeddings()
+ mock_store_batch.assert_not_called()
+
+ @_PATCH_DEPS
+ @_PATCH_EMBED_BATCH
+ @_PATCH_STORE_BATCH
+ @_PATCH_RECONCILE
+ def test_embeds_valid_function_with_source(
+ self,
+ _mock_reconcile: MagicMock,
+ mock_store_batch: MagicMock,
+ mock_embed_batch: MagicMock,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ temp_repo: Path,
+ ) -> None:
+ (temp_repo / "module.py").write_text("def hello():\n return 42\n")
+ row: ResultRow = {
+ cs.KEY_NODE_ID: 1,
+ cs.KEY_QUALIFIED_NAME: "myproject.module.hello",
+ cs.KEY_START_LINE: 1,
+ cs.KEY_END_LINE: 2,
+ cs.KEY_PATH: "module.py",
+ }
+ query_ingestor.fetch_all.return_value = [row]
+
+ updater_with_query._generate_semantic_embeddings()
+
+ mock_embed_batch.assert_called_once()
+ snippets_arg = mock_embed_batch.call_args[0][0]
+ assert len(snippets_arg) == 1
+ assert "def hello()" in snippets_arg[0]
+ mock_store_batch.assert_called_once()
+ batch_arg = mock_store_batch.call_args[0][0]
+ assert len(batch_arg) == 1
+ assert batch_arg[0] == (1, MOCK_EMBEDDING, "myproject.module.hello")
+
+ @_PATCH_DEPS
+ @_PATCH_EMBED_BATCH
+ @_PATCH_STORE_BATCH
+ @_PATCH_RECONCILE
+ def test_skips_row_with_missing_source_info(
+ self,
+ _mock_reconcile: MagicMock,
+ mock_store_batch: MagicMock,
+ mock_embed_batch: MagicMock,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ ) -> None:
+ row: ResultRow = {
+ cs.KEY_NODE_ID: 1,
+ cs.KEY_QUALIFIED_NAME: "myproject.module.hello",
+ }
+ query_ingestor.fetch_all.return_value = [row]
+
+ updater_with_query._generate_semantic_embeddings()
+
+ mock_embed_batch.assert_not_called()
+ mock_store_batch.assert_not_called()
+
+ @patch("codebase_rag.graph_updater.has_semantic_dependencies", return_value=True)
+ @patch(
+ "codebase_rag.embedder.embed_code_batch",
+ side_effect=RuntimeError("model error"),
+ )
+ @_PATCH_STORE_BATCH
+ @_PATCH_RECONCILE
+ def test_handles_embed_failure_gracefully(
+ self,
+ _mock_reconcile: MagicMock,
+ mock_store_batch: MagicMock,
+ _mock_embed_batch: MagicMock,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ temp_repo: Path,
+ ) -> None:
+ (temp_repo / "module.py").write_text("def hello():\n return 42\n")
+ row: ResultRow = {
+ cs.KEY_NODE_ID: 1,
+ cs.KEY_QUALIFIED_NAME: "myproject.module.hello",
+ cs.KEY_START_LINE: 1,
+ cs.KEY_END_LINE: 2,
+ cs.KEY_PATH: "module.py",
+ }
+ query_ingestor.fetch_all.return_value = [row]
+
+ updater_with_query._generate_semantic_embeddings()
+
+ mock_store_batch.assert_not_called()
+
+ @_PATCH_DEPS
+ @_PATCH_EMBED_BATCH
+ @_PATCH_STORE_BATCH
+ @_PATCH_RECONCILE
+ def test_skips_unparseable_rows(
+ self,
+ _mock_reconcile: MagicMock,
+ mock_store_batch: MagicMock,
+ mock_embed_batch: MagicMock,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ ) -> None:
+ bad_row: ResultRow = {
+ cs.KEY_NODE_ID: "not_an_int",
+ cs.KEY_QUALIFIED_NAME: "pkg.func",
+ }
+ query_ingestor.fetch_all.return_value = [bad_row]
+
+ updater_with_query._generate_semantic_embeddings()
+
+ mock_embed_batch.assert_not_called()
+ mock_store_batch.assert_not_called()
+
+ @_PATCH_DEPS
+ @_PATCH_EMBED_BATCH
+ @_PATCH_STORE_BATCH
+ @_PATCH_RECONCILE
+ def test_counts_embedded_functions(
+ self,
+ _mock_reconcile: MagicMock,
+ mock_store_batch: MagicMock,
+ mock_embed_batch: MagicMock,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ temp_repo: Path,
+ ) -> None:
+ (temp_repo / "a.py").write_text("def f1():\n pass\n")
+ (temp_repo / "b.py").write_text("def f2():\n pass\n")
+ rows: list[ResultRow] = [
+ {
+ cs.KEY_NODE_ID: 1,
+ cs.KEY_QUALIFIED_NAME: "proj.a.f1",
+ cs.KEY_START_LINE: 1,
+ cs.KEY_END_LINE: 2,
+ cs.KEY_PATH: "a.py",
+ },
+ {
+ cs.KEY_NODE_ID: 2,
+ cs.KEY_QUALIFIED_NAME: "proj.b.f2",
+ cs.KEY_START_LINE: 1,
+ cs.KEY_END_LINE: 2,
+ cs.KEY_PATH: "b.py",
+ },
+ ]
+ query_ingestor.fetch_all.return_value = rows
+
+ updater_with_query._generate_semantic_embeddings()
+
+ mock_embed_batch.assert_called_once()
+ snippets_arg = mock_embed_batch.call_args[0][0]
+ assert len(snippets_arg) == 2
+ mock_store_batch.assert_called_once()
+ batch_arg = mock_store_batch.call_args[0][0]
+ assert len(batch_arg) == 2
+
+
+class TestBatchedEmbeddingDispatch:
+ @_PATCH_DEPS
+ @_PATCH_EMBED_BATCH
+ @_PATCH_STORE_BATCH
+ @_PATCH_RECONCILE
+ def test_dispatches_single_batch_call_for_multiple_snippets(
+ self,
+ _mock_reconcile: MagicMock,
+ _mock_store_batch: MagicMock,
+ mock_embed_batch: MagicMock,
+ _mock_deps: MagicMock,
+ updater_with_query: GraphUpdater,
+ query_ingestor: MagicMock,
+ temp_repo: Path,
+ ) -> None:
+ (temp_repo / "a.py").write_text("def f1():\n return 1\n")
+ (temp_repo / "b.py").write_text("def f2():\n return 2\n")
+ (temp_repo / "c.py").write_text("def f3():\n return 3\n")
+ rows: list[ResultRow] = [
+ {
+ cs.KEY_NODE_ID: i + 1,
+ cs.KEY_QUALIFIED_NAME: f"proj.{name}.f{i + 1}",
+ cs.KEY_START_LINE: 1,
+ cs.KEY_END_LINE: 2,
+ cs.KEY_PATH: f"{name}.py",
+ }
+ for i, name in enumerate(("a", "b", "c"))
+ ]
+ query_ingestor.fetch_all.return_value = rows
+
+ updater_with_query._generate_semantic_embeddings()
+
+ assert mock_embed_batch.call_count == 1
+ snippets_arg = mock_embed_batch.call_args[0][0]
+ assert len(snippets_arg) == 3
diff --git a/codebase_rag/tests/test_graph_updater_incremental.py b/codebase_rag/tests/test_graph_updater_incremental.py
new file mode 100644
index 000000000..788e15358
--- /dev/null
+++ b/codebase_rag/tests/test_graph_updater_incremental.py
@@ -0,0 +1,457 @@
+import json
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import (
+ BoundedASTCache,
+ FunctionRegistryTrie,
+ GraphUpdater,
+ _hash_file,
+ _hash_file_with_bytes,
+ _load_hash_cache,
+ _save_hash_cache,
+)
+from codebase_rag.parser_loader import load_parsers
+
+
+@pytest.fixture
+def updater(temp_repo: Path, mock_ingestor: MagicMock) -> GraphUpdater:
+ parsers, queries = load_parsers()
+ return GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+
+
+@pytest.fixture
+def py_project(temp_repo: Path) -> Path:
+ (temp_repo / "__init__.py").touch()
+ (temp_repo / "module_a.py").write_text("def func_a():\n pass\n")
+ (temp_repo / "module_b.py").write_text("def func_b():\n pass\n")
+ return temp_repo
+
+
+class TestHashFile:
+ def test_hash_returns_hex_string(self, temp_repo: Path) -> None:
+ f = temp_repo / "test.py"
+ f.write_text("hello")
+ result = _hash_file(f)
+ assert isinstance(result, str)
+ assert len(result) == 32
+
+ def test_same_content_same_hash(self, temp_repo: Path) -> None:
+ f1 = temp_repo / "a.py"
+ f2 = temp_repo / "b.py"
+ f1.write_text("same content")
+ f2.write_text("same content")
+ assert _hash_file(f1) == _hash_file(f2)
+
+ def test_different_content_different_hash(self, temp_repo: Path) -> None:
+ f1 = temp_repo / "a.py"
+ f2 = temp_repo / "b.py"
+ f1.write_text("content one")
+ f2.write_text("content two")
+ assert _hash_file(f1) != _hash_file(f2)
+
+ def test_hash_with_bytes_returns_none_for_broken_symlink(
+ self, temp_repo: Path
+ ) -> None:
+ link = temp_repo / "result"
+ link.symlink_to(temp_repo / "missing-target")
+ assert _hash_file_with_bytes(link) is None
+
+ def test_hash_with_bytes_returns_none_for_missing_file(
+ self, temp_repo: Path
+ ) -> None:
+ assert _hash_file_with_bytes(temp_repo / "does-not-exist") is None
+
+
+class TestHashCacheIO:
+ def test_save_and_load_cache(self, temp_repo: Path) -> None:
+ cache_path = temp_repo / cs.HASH_CACHE_FILENAME
+ data = {"module_a.py": "abc123", "module_b.py": "def456"}
+ _save_hash_cache(cache_path, data)
+
+ assert cache_path.is_file()
+ loaded = _load_hash_cache(cache_path)
+ assert loaded == data
+
+ def test_load_nonexistent_returns_empty(self, temp_repo: Path) -> None:
+ cache_path = temp_repo / cs.HASH_CACHE_FILENAME
+ assert _load_hash_cache(cache_path) == {}
+
+ def test_load_corrupted_returns_empty(self, temp_repo: Path) -> None:
+ cache_path = temp_repo / cs.HASH_CACHE_FILENAME
+ cache_path.write_text("not valid json {{{")
+ assert _load_hash_cache(cache_path) == {}
+
+ def test_save_creates_parent_dirs(self, temp_repo: Path) -> None:
+ cache_path = temp_repo / "subdir" / "nested" / cs.HASH_CACHE_FILENAME
+ _save_hash_cache(cache_path, {"a.py": "hash1"})
+ assert cache_path.is_file()
+
+ def test_cache_file_is_valid_json(self, temp_repo: Path) -> None:
+ cache_path = temp_repo / cs.HASH_CACHE_FILENAME
+ data = {"file.py": "sha256hash"}
+ _save_hash_cache(cache_path, data)
+ with cache_path.open() as f:
+ parsed = json.load(f)
+ assert parsed == data
+
+
+class TestIncrementalUpdates:
+ def test_unchanged_file_is_skipped(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ mock_ingestor.reset_mock()
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ with patch.object(
+ updater2, "_process_single_file", wraps=updater2._process_single_file
+ ) as spy:
+ updater2.run()
+ assert spy.call_count == 0
+
+ def test_changed_file_is_reparsed(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ (py_project / "module_a.py").write_text("def func_a_updated():\n pass\n")
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ with patch.object(
+ updater2, "_process_single_file", wraps=updater2._process_single_file
+ ) as spy:
+ updater2.run()
+ processed_paths = [call.args[0] for call in spy.call_args_list]
+ assert py_project / "module_a.py" in processed_paths
+
+ def test_deleted_file_removed_from_state(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ (py_project / "module_b.py").unlink()
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ with patch.object(
+ updater2, "remove_file_from_state", wraps=updater2.remove_file_from_state
+ ) as spy:
+ updater2.run()
+ removed_paths = [call.args[0] for call in spy.call_args_list]
+ assert py_project / "module_b.py" in removed_paths
+
+ def test_force_bypasses_cache(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ with patch.object(
+ updater2, "_process_single_file", wraps=updater2._process_single_file
+ ) as spy:
+ updater2.run(force=True)
+ assert spy.call_count > 0
+
+ def test_new_file_is_processed(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ (py_project / "module_c.py").write_text("def func_c():\n pass\n")
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ with patch.object(
+ updater2, "_process_single_file", wraps=updater2._process_single_file
+ ) as spy:
+ updater2.run()
+ processed_paths = [call.args[0] for call in spy.call_args_list]
+ assert py_project / "module_c.py" in processed_paths
+
+ def test_hash_cache_file_created_after_run(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ cache_path = py_project / cs.HASH_CACHE_FILENAME
+ assert not cache_path.exists()
+
+ updater.run()
+
+ assert cache_path.is_file()
+ with cache_path.open() as f:
+ data = json.load(f)
+ assert isinstance(data, dict)
+ assert len(data) > 0
+
+ def test_broken_symlink_does_not_crash_indexing(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ broken = py_project / "result"
+ broken.symlink_to(py_project / "missing-nix-store-path")
+
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ updater.run()
+
+ cache_path = py_project / cs.HASH_CACHE_FILENAME
+ assert cache_path.is_file()
+ with cache_path.open() as f:
+ data = json.load(f)
+ assert "result" not in data
+ assert "module_a.py" in data
+
+ def test_deleted_file_removed_from_hash_cache(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ cache_path = py_project / cs.HASH_CACHE_FILENAME
+ with cache_path.open() as f:
+ old_data = json.load(f)
+ assert "module_b.py" in old_data
+
+ (py_project / "module_b.py").unlink()
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater2.run()
+
+ with cache_path.open() as f:
+ new_data = json.load(f)
+ assert "module_b.py" not in new_data
+
+
+class TestFastPathInSync:
+ def test_second_run_skips_all_passes(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ assert updater2._is_already_in_sync() is True
+ with (
+ patch.object(
+ updater2, "_process_single_file", wraps=updater2._process_single_file
+ ) as spy_files,
+ patch.object(updater2, "_process_function_calls") as spy_calls,
+ ):
+ updater2.run()
+ assert spy_files.call_count == 0
+ assert spy_calls.call_count == 0
+
+ def test_changed_file_disables_fast_path(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ (py_project / "module_a.py").write_text("def func_a():\n return 1\n")
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ assert updater2._is_already_in_sync() is False
+
+ def test_new_file_disables_fast_path(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ (py_project / "module_c.py").write_text("def func_c():\n pass\n")
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ assert updater2._is_already_in_sync() is False
+
+ def test_deleted_file_disables_fast_path(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ (py_project / "module_a.py").unlink()
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ assert updater2._is_already_in_sync() is False
+
+ def test_no_hash_cache_disables_fast_path(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ assert updater._is_already_in_sync() is False
+
+ def test_force_bypasses_fast_path(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ updater2 = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ with patch.object(updater2, "_process_function_calls") as spy_calls:
+ updater2.run(force=True)
+ spy_calls.assert_called_once()
+
+
+class TestSlots:
+ def test_function_registry_trie_has_slots(self) -> None:
+ assert hasattr(FunctionRegistryTrie, "__slots__")
+ trie = FunctionRegistryTrie()
+ with pytest.raises(AttributeError):
+ trie.nonexistent_attr = "value" # type: ignore[attr-defined]
+
+ def test_bounded_ast_cache_has_slots(self) -> None:
+ assert hasattr(BoundedASTCache, "__slots__")
+ cache = BoundedASTCache()
+ with pytest.raises(AttributeError):
+ cache.nonexistent_attr = "value" # type: ignore[attr-defined]
diff --git a/codebase_rag/tests/test_graph_updater_incremental_rename.py b/codebase_rag/tests/test_graph_updater_incremental_rename.py
new file mode 100644
index 000000000..ae6fc786b
--- /dev/null
+++ b/codebase_rag/tests/test_graph_updater_incremental_rename.py
@@ -0,0 +1,190 @@
+# (H) Regression tests for Codeberg issue #1: incremental rebuild used to leave
+# (H) stale Function/DEFINES/IMPORTS/CALLS entities when a symbol was renamed
+# (H) across files, because the incremental path was additive-only. After the
+# (H) fix, an incremental rebuild after a rename must yield exactly the same
+# (H) graph as a fresh full rebuild of the renamed tree.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT_NAME = "testproj"
+
+NodeId = tuple[str, PropertyValue]
+RelTuple = tuple[str, str, PropertyValue, str, str, str, PropertyValue]
+
+_DEFINES_EDGES = (cs.RelationshipType.DEFINES, cs.RelationshipType.DEFINES_METHOD)
+
+
+class InMemoryGraph:
+ """Minimal in-memory ingestor that applies the exact node/relationship
+ writes and the DETACH-DELETE queries the updater issues, so final graph
+ state can be compared between incremental and full rebuilds."""
+
+ def __init__(self) -> None:
+ self.nodes: dict[NodeId, PropertyDict] = {}
+ self.rels: set[RelTuple] = set()
+
+ # (H) IngestorProtocol
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ uid = properties[NODE_UNIQUE_KEYS[label]]
+ self.nodes[(str(label), uid)] = dict(properties)
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ fl, fk, fv = from_spec
+ tl, tk, tv = to_spec
+ self.rels.add((str(fl), str(fk), fv, str(rel_type), str(tl), str(tk), tv))
+
+ def flush_all(self) -> None:
+ return None
+
+ # (H) QueryProtocol
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ params = params or {}
+ path = params.get(cs.KEY_PATH)
+ match query:
+ case cs.CYPHER_DELETE_MODULE:
+ self._delete_module_subtree(path)
+ case cs.CYPHER_DELETE_FILE:
+ self._delete_node_by_path(cs.NodeLabel.FILE, path)
+ case cs.CYPHER_DELETE_FOLDER:
+ self._delete_node_by_path(cs.NodeLabel.FOLDER, path)
+ case _:
+ return None
+
+ # (H) delete helpers
+ def _find_nodes(self, label: str, key: str, val: PropertyValue) -> list[NodeId]:
+ return [
+ nid
+ for nid, props in self.nodes.items()
+ if nid[0] == label and props.get(key) == val
+ ]
+
+ def _delete_module_subtree(self, path: PropertyValue) -> None:
+ seeds = [
+ nid
+ for nid, props in self.nodes.items()
+ if nid[0] == cs.NodeLabel.MODULE and props.get(cs.KEY_PATH) == path
+ ]
+ to_delete: set[NodeId] = set()
+ stack = list(seeds)
+ while stack:
+ nid = stack.pop()
+ if nid in to_delete:
+ continue
+ to_delete.add(nid)
+ props = self.nodes[nid]
+ for fl, fk, fv, rt, tl, tk, tv in self.rels:
+ if rt in _DEFINES_EDGES and fl == nid[0] and props.get(fk) == fv:
+ for child in self._find_nodes(tl, tk, tv):
+ if child not in to_delete:
+ stack.append(child)
+ self._purge_nodes(to_delete)
+
+ def _delete_node_by_path(self, label: str, path: PropertyValue) -> None:
+ self._purge_nodes(set(self._find_nodes(label, cs.KEY_PATH, path)))
+
+ def _purge_nodes(self, to_delete: set[NodeId]) -> None:
+ deleted_props = {nid: self.nodes[nid] for nid in to_delete}
+ for nid in to_delete:
+ self.nodes.pop(nid, None)
+
+ def touches(label: str, key: str, val: PropertyValue) -> bool:
+ return any(
+ nid[0] == label and props.get(key) == val
+ for nid, props in deleted_props.items()
+ )
+
+ self.rels = {
+ (fl, fk, fv, rt, tl, tk, tv)
+ for (fl, fk, fv, rt, tl, tk, tv) in self.rels
+ if not touches(fl, fk, fv) and not touches(tl, tk, tv)
+ }
+
+ # (H) comparison
+ def snapshot(self) -> tuple[frozenset[NodeId], frozenset[RelTuple]]:
+ return frozenset(self.nodes.keys()), frozenset(self.rels)
+
+
+NODE_UNIQUE_KEYS = cs.NODE_UNIQUE_CONSTRAINTS
+
+
+def _write_tree(root: Path, new_name: str) -> None:
+ (root / "__init__.py").touch()
+ (root / "a.py").write_text(f"def {new_name}():\n return 1\n")
+ (root / "b.py").write_text(
+ f"from .a import {new_name}\n\n\ndef caller():\n return {new_name}()\n"
+ )
+
+
+def _make_updater(root: Path, ingestor: InMemoryGraph) -> GraphUpdater:
+ parsers, queries = load_parsers()
+ return GraphUpdater(
+ ingestor=ingestor,
+ repo_path=root,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT_NAME,
+ )
+
+
+class TestIncrementalRenameStaleEntities:
+ def test_incremental_rename_matches_full_rebuild(self, tmp_path: Path) -> None:
+ # (H) Golden: a fresh full rebuild of the already-renamed tree.
+ golden_root = tmp_path / "golden"
+ golden_root.mkdir()
+ _write_tree(golden_root, "new_name")
+ golden_graph = InMemoryGraph()
+ _make_updater(golden_root, golden_graph).run(force=True)
+
+ # (H) Sanity: golden truly contains the renamed symbol and not the old one.
+ golden_funcs = {
+ uid for (label, uid) in golden_graph.nodes if label == cs.NodeLabel.FUNCTION
+ }
+ assert any(str(qn).endswith(".new_name") for qn in golden_funcs)
+ assert not any(str(qn).endswith(".old_name") for qn in golden_funcs)
+
+ # (H) Incremental: build original tree, then rename across both files
+ # (H) and rebuild incrementally (force=False).
+ incr_root = tmp_path / "incr"
+ incr_root.mkdir()
+ _write_tree(incr_root, "old_name")
+ incr_graph = InMemoryGraph()
+ _make_updater(incr_root, incr_graph).run(force=True)
+
+ _write_tree(incr_root, "new_name")
+ _make_updater(incr_root, incr_graph).run(force=False)
+
+ # (H) The stale old_name Function and its edges must be gone.
+ incr_nodes, incr_rels = incr_graph.snapshot()
+ golden_nodes, golden_rels = golden_graph.snapshot()
+
+ assert incr_nodes == golden_nodes, {
+ "stale_extra_nodes": sorted(map(str, incr_nodes - golden_nodes)),
+ "missing_nodes": sorted(map(str, golden_nodes - incr_nodes)),
+ }
+ assert incr_rels == golden_rels, {
+ "stale_extra_rels": sorted(map(str, incr_rels - golden_rels)),
+ "missing_rels": sorted(map(str, golden_rels - incr_rels)),
+ }
+
+
+if __name__ == "__main__":
+ pytest.main([__file__, "-v"])
diff --git a/codebase_rag/tests/test_graph_updater_pruning.py b/codebase_rag/tests/test_graph_updater_pruning.py
new file mode 100644
index 000000000..a8d5419cc
--- /dev/null
+++ b/codebase_rag/tests/test_graph_updater_pruning.py
@@ -0,0 +1,369 @@
+# (H) Tests for orphan node pruning in GraphUpdater._prune_orphan_nodes
+# (H) and Cypher deletion in _process_files for hash-cache-detected deletions.
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+
+
+@pytest.fixture
+def updater(temp_repo: Path, mock_ingestor: MagicMock) -> GraphUpdater:
+ parsers, queries = load_parsers()
+ return GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+
+
+@pytest.fixture
+def py_project(temp_repo: Path) -> Path:
+ (temp_repo / "__init__.py").touch()
+ (temp_repo / "module_a.py").write_text("def func_a():\n pass\n")
+ (temp_repo / "module_b.py").write_text("def func_b():\n pass\n")
+ sub = temp_repo / "subpkg"
+ sub.mkdir()
+ (sub / "__init__.py").touch()
+ (sub / "inner.py").write_text("def inner_func():\n pass\n")
+ return temp_repo
+
+
+class TestPruneOrphanNodes:
+ def test_prune_removes_orphan_module_nodes(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+ project_name = py_project.resolve().name
+
+ mock_ingestor.fetch_all.side_effect = [
+ [],
+ [
+ {
+ "path": "old_project/main.py",
+ "qualified_name": f"{project_name}.old_project.main",
+ },
+ {
+ "path": "module_a.py",
+ "qualified_name": f"{project_name}.module_a",
+ },
+ ],
+ [],
+ ]
+ updater._prune_orphan_nodes()
+
+ delete_calls = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0] == cs.CYPHER_DELETE_MODULE
+ ]
+ assert len(delete_calls) == 1
+ assert delete_calls[0].args[1] == {cs.KEY_PATH: "old_project/main.py"}
+
+ def test_prune_removes_orphan_external_module_nodes(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ mock_ingestor.fetch_all.side_effect = [[], [], []]
+ updater._prune_orphan_nodes()
+
+ external_calls = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0] == cs.CYPHER_DELETE_ORPHAN_EXTERNAL_MODULES
+ ]
+ assert len(external_calls) == 1
+
+ def test_prune_skips_other_projects(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ mock_ingestor.fetch_all.side_effect = [
+ [{"path": "app.py", "absolute_path": "/other/project/app.py"}],
+ [{"path": "app.py", "qualified_name": "other_project.app"}],
+ [{"path": "data", "absolute_path": "/other/project/data"}],
+ ]
+ updater._prune_orphan_nodes()
+
+ path_deletes = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0]
+ in (cs.CYPHER_DELETE_FILE, cs.CYPHER_DELETE_MODULE, cs.CYPHER_DELETE_FOLDER)
+ ]
+ assert path_deletes == []
+
+ def test_prune_no_orphans_skips_deletes(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ project_name = py_project.resolve().name
+ repo_abs = py_project.resolve().as_posix()
+ mock_ingestor.fetch_all.side_effect = [
+ [{"path": "module_a.py", "absolute_path": f"{repo_abs}/module_a.py"}],
+ [{"path": "module_a.py", "qualified_name": f"{project_name}.module_a"}],
+ [{"path": "subpkg", "absolute_path": f"{repo_abs}/subpkg"}],
+ ]
+ updater._prune_orphan_nodes()
+
+ path_deletes = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0]
+ in (cs.CYPHER_DELETE_FILE, cs.CYPHER_DELETE_MODULE, cs.CYPHER_DELETE_FOLDER)
+ ]
+ assert path_deletes == []
+
+ def test_prune_handles_empty_graph(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ mock_ingestor.fetch_all.side_effect = [[], [], []]
+ updater._prune_orphan_nodes()
+
+ path_deletes = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0]
+ in (cs.CYPHER_DELETE_FILE, cs.CYPHER_DELETE_MODULE, cs.CYPHER_DELETE_FOLDER)
+ ]
+ assert path_deletes == []
+
+ def test_prune_handles_none_path_gracefully(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ project_name = py_project.resolve().name
+ mock_ingestor.fetch_all.side_effect = [
+ [{"path": None, "absolute_path": None}],
+ [
+ {"path": None, "qualified_name": f"{project_name}.something"},
+ {"path": "module_a.py", "qualified_name": f"{project_name}.module_a"},
+ ],
+ [],
+ ]
+ updater._prune_orphan_nodes()
+
+ path_deletes = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0]
+ in (cs.CYPHER_DELETE_FILE, cs.CYPHER_DELETE_MODULE, cs.CYPHER_DELETE_FOLDER)
+ ]
+ assert path_deletes == []
+
+ def test_prune_multiple_orphans_across_types(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ project_name = py_project.resolve().name
+ repo_abs = py_project.resolve().as_posix()
+ mock_ingestor.fetch_all.side_effect = [
+ [
+ {"path": "gone.py", "absolute_path": f"{repo_abs}/gone.py"},
+ {"path": "module_a.py", "absolute_path": f"{repo_abs}/module_a.py"},
+ ],
+ [
+ {
+ "path": "deleted.py",
+ "qualified_name": f"{project_name}.deleted",
+ },
+ {
+ "path": "module_a.py",
+ "qualified_name": f"{project_name}.module_a",
+ },
+ ],
+ [
+ {"path": "old_dir", "absolute_path": f"{repo_abs}/old_dir"},
+ {"path": "subpkg", "absolute_path": f"{repo_abs}/subpkg"},
+ ],
+ ]
+ updater._prune_orphan_nodes()
+
+ path_deletes = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0]
+ in (cs.CYPHER_DELETE_FILE, cs.CYPHER_DELETE_MODULE, cs.CYPHER_DELETE_FOLDER)
+ ]
+ assert len(path_deletes) == 3
+
+ def test_prune_skips_inline_module_synthetic_paths(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ project_name = py_project.resolve().name
+ inline_path_tests = f"{cs.INLINE_MODULE_PATH_PREFIX}tests"
+ inline_path_macos = f"{cs.INLINE_MODULE_PATH_PREFIX}macos"
+ mock_ingestor.fetch_all.side_effect = [
+ [],
+ [
+ {
+ "path": inline_path_tests,
+ "qualified_name": f"{project_name}.src.app.tests",
+ },
+ {
+ "path": inline_path_tests,
+ "qualified_name": f"{project_name}.src.cli.tests",
+ },
+ {
+ "path": inline_path_macos,
+ "qualified_name": f"{project_name}.src.clipboard.macos",
+ },
+ ],
+ [],
+ ]
+ updater._prune_orphan_nodes()
+
+ delete_module_calls = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0] == cs.CYPHER_DELETE_MODULE
+ ]
+ assert delete_module_calls == []
+
+
+class TestCypherDeleteModuleQuery:
+ def test_query_does_not_traverse_calls_edges(self) -> None:
+ query = cs.CYPHER_DELETE_MODULE
+ assert "-[*0..]->" not in query
+ assert "-[*]->" not in query
+
+ def test_query_constrains_traversal_to_containment_edges(self) -> None:
+ query = cs.CYPHER_DELETE_MODULE
+ assert "DEFINES" in query
+ assert "CALLS" not in query
+ assert "IMPORTS" not in query
+ assert "INHERITS" not in query
+
+
+class TestDeletedFileInProcessFiles:
+ def test_deleted_file_triggers_cypher_delete(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ updater.run(force=True)
+ mock_ingestor.execute_write.reset_mock()
+
+ (py_project / "module_b.py").unlink()
+ updater.run(force=False)
+
+ delete_module_calls = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0] == cs.CYPHER_DELETE_MODULE
+ ]
+ delete_file_calls = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0] == cs.CYPHER_DELETE_FILE
+ ]
+ assert len(delete_module_calls) >= 1
+ assert len(delete_file_calls) >= 1
+
+ def test_no_deletes_when_no_files_removed(
+ self, py_project: Path, mock_ingestor: MagicMock
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ updater.run(force=True)
+ mock_ingestor.execute_write.reset_mock()
+
+ updater.run(force=False)
+
+ delete_calls = [
+ c
+ for c in mock_ingestor.execute_write.call_args_list
+ if c.args[0] in (cs.CYPHER_DELETE_MODULE, cs.CYPHER_DELETE_FILE)
+ ]
+ assert len(delete_calls) == 0
+
+ @patch("codebase_rag.graph_updater.GraphUpdater._prune_orphan_nodes")
+ def test_run_calls_prune(
+ self,
+ mock_prune: MagicMock,
+ py_project: Path,
+ mock_ingestor: MagicMock,
+ ) -> None:
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=py_project,
+ parsers=parsers,
+ queries=queries,
+ )
+
+ updater.run(force=True)
+ mock_prune.assert_called_once()
diff --git a/codebase_rag/tests/test_handler_registry.py b/codebase_rag/tests/test_handler_registry.py
index 2a9215755..6b7259f18 100644
--- a/codebase_rag/tests/test_handler_registry.py
+++ b/codebase_rag/tests/test_handler_registry.py
@@ -9,6 +9,7 @@
from codebase_rag.parsers.handlers.java import JavaHandler
from codebase_rag.parsers.handlers.js_ts import JsTsHandler
from codebase_rag.parsers.handlers.lua import LuaHandler
+from codebase_rag.parsers.handlers.php import PhpHandler
from codebase_rag.parsers.handlers.python import PythonHandler
from codebase_rag.parsers.handlers.rust import RustHandler
@@ -47,8 +48,12 @@ def test_returns_base_handler_for_go(self) -> None:
assert isinstance(handler, BaseLanguageHandler)
assert type(handler) is BaseLanguageHandler
- def test_returns_base_handler_for_php(self) -> None:
+ def test_returns_php_handler_for_php(self) -> None:
handler = get_handler(SupportedLanguage.PHP)
+ assert isinstance(handler, PhpHandler)
+
+ def test_returns_base_handler_for_c(self) -> None:
+ handler = get_handler(SupportedLanguage.C)
assert isinstance(handler, BaseLanguageHandler)
assert type(handler) is BaseLanguageHandler
@@ -84,6 +89,7 @@ class TestHandlerProtocol:
SupportedLanguage.PYTHON,
SupportedLanguage.GO,
SupportedLanguage.PHP,
+ SupportedLanguage.C,
],
)
def test_handler_has_all_protocol_methods(
@@ -114,6 +120,8 @@ def test_handler_has_all_protocol_methods(
SupportedLanguage.JAVA,
SupportedLanguage.LUA,
SupportedLanguage.PYTHON,
+ SupportedLanguage.PHP,
+ SupportedLanguage.C,
],
)
def test_handler_methods_are_callable(self, language: SupportedLanguage) -> None:
@@ -151,3 +159,6 @@ def test_lua_handler_extends_base(self) -> None:
def test_python_handler_extends_base(self) -> None:
assert issubclass(PythonHandler, BaseLanguageHandler)
+
+ def test_php_handler_extends_base(self) -> None:
+ assert issubclass(PhpHandler, BaseLanguageHandler)
diff --git a/codebase_rag/tests/test_handlers_unit.py b/codebase_rag/tests/test_handlers_unit.py
index a9391ecde..f34d42d86 100644
--- a/codebase_rag/tests/test_handlers_unit.py
+++ b/codebase_rag/tests/test_handlers_unit.py
@@ -13,6 +13,7 @@
from codebase_rag.parsers.handlers.java import JavaHandler
from codebase_rag.parsers.handlers.js_ts import JsTsHandler
from codebase_rag.parsers.handlers.lua import LuaHandler
+from codebase_rag.parsers.handlers.php import PhpHandler
from codebase_rag.parsers.handlers.python import PythonHandler
from codebase_rag.parsers.handlers.rust import RustHandler
from codebase_rag.tests.conftest import create_mock_node
@@ -62,6 +63,13 @@
except ImportError:
LUA_AVAILABLE = False
+try:
+ import tree_sitter_php as tsphp
+
+ PHP_AVAILABLE = True
+except ImportError:
+ PHP_AVAILABLE = False
+
@pytest.fixture
def js_parser() -> Parser | None:
@@ -111,6 +119,14 @@ def lua_parser() -> Parser | None:
return Parser(language)
+@pytest.fixture
+def php_parser() -> Parser | None:
+ if not PHP_AVAILABLE:
+ return None
+ language = Language(tsphp.language_php())
+ return Parser(language)
+
+
class TestBaseLanguageHandler:
def test_is_inside_method_with_object_literals_returns_false(self) -> None:
handler = BaseLanguageHandler()
@@ -1105,3 +1121,168 @@ def test_extract_decorators_dataclass_with_options(
result = handler.extract_decorators(class_node)
assert result == ["@dataclass(frozen=True, slots=True)"]
+
+
+def _find_php_node(root: ASTNode, node_type: str) -> ASTNode | None:
+ if root.type == node_type:
+ return root
+ for child in root.children:
+ if result := _find_php_node(child, node_type):
+ return result
+ return None
+
+
+@pytest.mark.skipif(not PHP_AVAILABLE, reason="tree-sitter-php not available")
+class TestPhpHandler:
+ def test_extract_function_name_from_function_definition(
+ self, php_parser: Parser
+ ) -> None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" 2;"
+ tree = php_parser.parse(code)
+ arrow_node = _find_php_node(tree.root_node, cs.TS_PHP_ARROW_FUNCTION)
+ assert arrow_node is not None
+
+ result = handler.extract_function_name(arrow_node)
+ assert result is not None
+ assert result.startswith("arrow_")
+
+ def test_is_class_method_inside_class(self, php_parser: Parser) -> None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b' None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b" None:
+ handler = PhpHandler()
+ code = b' int:
+ return 1
+
+ def keyfn(self) -> int:
+ return 2
+"""
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "m.py").write_text(MODULE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestHigherOrderCalls:
+ def test_callable_parameter_resolves_to_argument_at_call_site(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.apply_cb", "proj.m.helper") in calls, calls
+
+ def test_callback_attributed_to_invoking_callee_not_caller(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ # (H) driver passes helper but never invokes it; apply_cb does.
+ assert ("proj.m.driver", "proj.m.helper") not in calls, calls
+
+ def test_callable_parameter_prefers_module_function_over_sibling_method(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.apply_cb", "proj.m.Other.helper") not in calls, calls
+
+ def test_sorted_key_attributed_to_enclosing_function(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.do_sort", "proj.m.keyfn") in calls, calls
+
+ def test_normal_call_edge_to_callee_still_present(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.driver", "proj.m.apply_cb") in calls, calls
diff --git a/codebase_rag/tests/test_image_paths.py b/codebase_rag/tests/test_image_paths.py
deleted file mode 100644
index 8daeba0db..000000000
--- a/codebase_rag/tests/test_image_paths.py
+++ /dev/null
@@ -1,160 +0,0 @@
-from pathlib import Path
-
-import pytest
-
-from codebase_rag.main import (
- _find_image_paths,
- _get_path_variants,
- _handle_chat_images,
- _replace_path_in_question,
-)
-
-
-class TestFindImagePaths:
- def test_finds_png_path(self) -> None:
- question = "What is in this image /home/user/screenshot.png please analyze"
- result = _find_image_paths(question)
- assert result == [Path("/home/user/screenshot.png")]
-
- def test_finds_jpg_path(self) -> None:
- question = "Look at /tmp/photo.jpg"
- result = _find_image_paths(question)
- assert result == [Path("/tmp/photo.jpg")]
-
- def test_finds_jpeg_path(self) -> None:
- question = "Check /var/images/pic.jpeg"
- result = _find_image_paths(question)
- assert result == [Path("/var/images/pic.jpeg")]
-
- def test_finds_gif_path(self) -> None:
- question = "Analyze /home/user/animation.gif"
- result = _find_image_paths(question)
- assert result == [Path("/home/user/animation.gif")]
-
- def test_finds_multiple_images(self) -> None:
- question = "Compare /img/a.png and /img/b.jpg"
- result = _find_image_paths(question)
- assert result == [Path("/img/a.png"), Path("/img/b.jpg")]
-
- def test_case_insensitive_extension(self) -> None:
- question = "Look at /path/IMAGE.PNG and /path/photo.JPG"
- result = _find_image_paths(question)
- assert len(result) == 2
- assert Path("/path/IMAGE.PNG") in result
- assert Path("/path/photo.JPG") in result
-
- def test_ignores_relative_paths(self) -> None:
- question = "Check images/photo.png and ./local/pic.jpg"
- result = _find_image_paths(question)
- assert result == []
-
- def test_ignores_non_image_extensions(self) -> None:
- question = "Look at /path/document.pdf and /path/code.py"
- result = _find_image_paths(question)
- assert result == []
-
- def test_empty_question(self) -> None:
- result = _find_image_paths("")
- assert result == []
-
- def test_no_paths(self) -> None:
- question = "What is the meaning of life?"
- result = _find_image_paths(question)
- assert result == []
-
- def test_handles_quoted_paths(self) -> None:
- question = 'Look at "/path/with spaces/image.png"'
- result = _find_image_paths(question)
- assert result == [Path("/path/with spaces/image.png")]
-
-
-class TestGetPathVariants:
- def test_returns_four_variants(self) -> None:
- result = _get_path_variants("/path/to/file.png")
- assert len(result) == 4
-
- def test_includes_escaped_spaces(self) -> None:
- result = _get_path_variants("/path/with spaces/file.png")
- assert r"/path/with\ spaces/file.png" in result
-
- def test_includes_single_quoted(self) -> None:
- result = _get_path_variants("/path/to/file.png")
- assert "'/path/to/file.png'" in result
-
- def test_includes_double_quoted(self) -> None:
- result = _get_path_variants("/path/to/file.png")
- assert '"/path/to/file.png"' in result
-
- def test_includes_original(self) -> None:
- path = "/path/to/file.png"
- result = _get_path_variants(path)
- assert path in result
-
-
-class TestReplacePathInQuestion:
- def test_replaces_simple_path(self) -> None:
- question = "Look at /old/path.png please"
- result = _replace_path_in_question(question, "/old/path.png", "/new/path.png")
- assert result == "Look at /new/path.png please"
-
- def test_replaces_quoted_path(self) -> None:
- question = "Look at '/old/path.png' please"
- result = _replace_path_in_question(question, "/old/path.png", "/new/path.png")
- assert result == "Look at '/new/path.png' please"
-
- def test_replaces_double_quoted_path(self) -> None:
- question = 'Look at "/old/path.png" please'
- result = _replace_path_in_question(question, "/old/path.png", "/new/path.png")
- assert result == 'Look at "/new/path.png" please'
-
- def test_returns_original_if_not_found(self) -> None:
- question = "No path here"
- result = _replace_path_in_question(question, "/missing.png", "/new.png")
- assert result == question
-
-
-class TestHandleChatImages:
- @pytest.fixture
- def temp_project(self, tmp_path: Path) -> Path:
- return tmp_path
-
- @pytest.fixture
- def temp_image(self, tmp_path: Path) -> Path:
- img_path = tmp_path / "test_image.png"
- img_path.write_bytes(b"fake png content")
- return img_path
-
- def test_no_images_returns_unchanged(self, temp_project: Path) -> None:
- question = "What is 2 + 2?"
- result = _handle_chat_images(question, temp_project)
- assert result == question
-
- def test_copies_image_to_tmp(self, temp_project: Path, temp_image: Path) -> None:
- question = f"Look at {temp_image}"
- result = _handle_chat_images(question, temp_project)
-
- assert ".tmp" in result
- assert "test_image.png" in result
-
- tmp_dir = temp_project / ".tmp"
- assert tmp_dir.exists()
- copied_files = list(tmp_dir.glob("*test_image.png"))
- assert len(copied_files) == 1
-
- def test_handles_nonexistent_image(self, temp_project: Path) -> None:
- question = "Look at /nonexistent/image.png"
- result = _handle_chat_images(question, temp_project)
- assert result == question
-
- def test_handles_multiple_images(self, temp_project: Path) -> None:
- img1 = temp_project / "img1.png"
- img2 = temp_project / "img2.jpg"
- img1.write_bytes(b"png1")
- img2.write_bytes(b"jpg2")
-
- question = f"Compare {img1} and {img2}"
- result = _handle_chat_images(question, temp_project)
-
- assert ".tmp" in result
- assert "img1.png" in result
- assert "img2.jpg" in result
diff --git a/codebase_rag/tests/test_import_parsing.py b/codebase_rag/tests/test_import_parsing.py
index 318b146e3..2091d4195 100644
--- a/codebase_rag/tests/test_import_parsing.py
+++ b/codebase_rag/tests/test_import_parsing.py
@@ -475,3 +475,103 @@ def test_internal_import_matched_with_dot_separator(
assert result == "myapp.utils.Helper"
assert len(mock_ingestor.nodes_created) == 0
+
+
+class TestIsLocalModuleCache:
+ def test_is_local_module_cache_returns_correct_result(self, tmp_path: Path) -> None:
+ (tmp_path / "utils").mkdir()
+ (tmp_path / "utils" / "__init__.py").touch()
+
+ processor = ImportProcessor(
+ repo_path=tmp_path,
+ project_name="myproject",
+ ingestor=None,
+ function_registry=None,
+ )
+
+ assert processor._is_local_module("utils") is True
+ assert processor._is_local_module("nonexistent") is False
+
+ def test_is_local_module_cache_hits_on_repeated_calls(self, tmp_path: Path) -> None:
+ (tmp_path / "models").mkdir()
+ (tmp_path / "models" / "__init__.py").touch()
+
+ processor = ImportProcessor(
+ repo_path=tmp_path,
+ project_name="myproject",
+ ingestor=None,
+ function_registry=None,
+ )
+
+ processor._is_local_module("models")
+ processor._is_local_module("models")
+ processor._is_local_module("models")
+
+ info = processor._is_local_module_cached.cache_info()
+ assert info.hits >= 2
+ assert info.misses == 1
+
+ def test_is_local_module_detects_py_file(self, tmp_path: Path) -> None:
+ (tmp_path / "helpers.py").touch()
+
+ processor = ImportProcessor(
+ repo_path=tmp_path,
+ project_name="myproject",
+ ingestor=None,
+ function_registry=None,
+ )
+
+ assert processor._is_local_module("helpers") is True
+
+ def test_is_local_module_detects_directory(self, tmp_path: Path) -> None:
+ (tmp_path / "services").mkdir()
+
+ processor = ImportProcessor(
+ repo_path=tmp_path,
+ project_name="myproject",
+ ingestor=None,
+ function_registry=None,
+ )
+
+ assert processor._is_local_module("services") is True
+
+ def test_is_local_java_import_cache_hits(self, tmp_path: Path) -> None:
+ (tmp_path / "com").mkdir()
+
+ processor = ImportProcessor(
+ repo_path=tmp_path,
+ project_name="myproject",
+ ingestor=None,
+ function_registry=None,
+ )
+
+ processor._is_local_java_import("com.example.Service")
+ processor._is_local_java_import("com.example.Service")
+ processor._is_local_java_import("com.example.Service")
+
+ info = processor._is_local_java_import_cached.cache_info()
+ assert info.hits >= 2
+ assert info.misses == 1
+
+ def test_separate_instances_have_independent_caches(self, tmp_path: Path) -> None:
+ (tmp_path / "shared").mkdir()
+
+ p1 = ImportProcessor(
+ repo_path=tmp_path,
+ project_name="project1",
+ ingestor=None,
+ function_registry=None,
+ )
+ p2 = ImportProcessor(
+ repo_path=tmp_path,
+ project_name="project2",
+ ingestor=None,
+ function_registry=None,
+ )
+
+ p1._is_local_module("shared")
+ p1._is_local_module("shared")
+
+ info2 = p2._is_local_module_cached.cache_info()
+ assert info2.hits == 0
+ assert info2.misses == 0
diff --git a/codebase_rag/tests/test_inherits_attribute_base.py b/codebase_rag/tests/test_inherits_attribute_base.py
new file mode 100644
index 000000000..f057758cf
--- /dev/null
+++ b/codebase_rag/tests/test_inherits_attribute_base.py
@@ -0,0 +1,85 @@
+# (H) L2 finding from the evals/ harness: cgr captured INHERITS for direct-name
+# (H) bases (class C(Base)) but dropped attribute-style bases (class C(mod.Base),
+# (H) e.g. class UniXcoder(nn.Module)). Those inheritance edges must be captured.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "inhproj"
+
+MODULE_SRC = """from collections import abc
+
+
+class C(abc.Mapping):
+ pass
+"""
+
+_RelTuple = tuple[str, PropertyValue, str, str, PropertyValue]
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.nodes: dict[tuple[str, PropertyValue], PropertyDict] = {}
+ self.rels: list[_RelTuple] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ uid = properties[cs.NODE_UNIQUE_CONSTRAINTS[label]]
+ self.nodes[(str(label), uid)] = dict(properties)
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append(
+ (
+ str(from_spec[0]),
+ from_spec[2],
+ str(rel_type),
+ str(to_spec[0]),
+ to_spec[2],
+ )
+ )
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _build(tmp_path: Path) -> _Capture:
+ (tmp_path / "m.py").write_text(MODULE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return cap
+
+
+class TestInheritsAttributeBase:
+ def test_attribute_base_class_creates_inherits_edge(self, tmp_path: Path) -> None:
+ cap = _build(tmp_path)
+ targets = [
+ str(target).rsplit(cs.SEPARATOR_DOT, 1)[-1]
+ for (_fl, from_val, rel_type, _tl, target) in cap.rels
+ if rel_type == cs.RelationshipType.INHERITS and str(from_val).endswith(".C")
+ ]
+ assert targets == ["Mapping"], targets
diff --git a/codebase_rag/tests/test_instance_attr_type_inference.py b/codebase_rag/tests/test_instance_attr_type_inference.py
new file mode 100644
index 000000000..d28e30319
--- /dev/null
+++ b/codebase_rag/tests/test_instance_attr_type_inference.py
@@ -0,0 +1,111 @@
+# (H) L3 finding from the evals/ harness: a method calls self.attr.method(), but the
+# (H) type of self.attr is only knowable from the __init__ assignment in the same
+# (H) class. cgr scanned only the calling method for self-assignments, so the type
+# (H) was unknown and an ambiguous bare name resolved to the wrong global. Instance
+# (H) attributes assigned in __init__ must be visible to every method of the class.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+MODULE_SRC = """def run() -> str:
+ return "global"
+
+
+def status() -> str:
+ return "globalprop"
+
+
+class Helper:
+ def run(self) -> str:
+ return "real"
+
+ @property
+ def status(self) -> str:
+ return "ok"
+
+
+class App:
+ def __init__(self) -> None:
+ self.helper = Helper()
+
+ def go(self) -> str:
+ return self.helper.run()
+
+ def check(self) -> str:
+ return self.helper.status
+"""
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "m.py").write_text(MODULE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestInstanceAttrTypeInference:
+ def test_method_call_resolves_via_init_attribute_type(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.App.go", "proj.m.Helper.run") in calls, calls
+
+ def test_ambiguous_method_does_not_resolve_to_module_function(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.App.go", "proj.m.run") not in calls, calls
+
+ def test_property_access_resolves_via_init_attribute_type(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.App.check", "proj.m.Helper.status") in calls, calls
+
+ def test_property_access_not_resolved_to_module_function(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.App.check", "proj.m.status") not in calls, calls
diff --git a/codebase_rag/tests/test_interprocedural_callback_flow.py b/codebase_rag/tests/test_interprocedural_callback_flow.py
new file mode 100644
index 000000000..6369ad22a
--- /dev/null
+++ b/codebase_rag/tests/test_interprocedural_callback_flow.py
@@ -0,0 +1,94 @@
+# (H) L3 finding from the evals/ harness: extract_java_interface_names invokes a
+# (H) resolve_to_qn callback that is threaded through extract_implemented_interfaces from
+# (H) a caller that passes self._resolve_to_qn. The concrete callable is bound at the
+# (H) outer call site and flows through pass-through parameters to where it is finally
+# (H) invoked, so resolving the edge needs inter-procedural callback propagation.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+FILES = {
+ "pkg/__init__.py": "",
+ # (H) extract_names invokes the callback; extract_interfaces only passes it through.
+ "pkg/extract.py": (
+ "def extract_names(node, out, scope, resolve_to_qn):\n"
+ ' out.append(resolve_to_qn("x", scope))\n\n\n'
+ "def extract_interfaces(node, scope, resolve_to_qn):\n"
+ " out = []\n"
+ " extract_names(node, out, scope, resolve_to_qn)\n"
+ " return out\n"
+ ),
+ "pkg/driver.py": (
+ "from .extract import extract_interfaces\n\n\n"
+ "class Driver:\n"
+ " def resolve(self, name, scope):\n"
+ " return name\n\n"
+ " def run(self, node):\n"
+ ' return extract_interfaces(node, "s", self.resolve)\n'
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestInterproceduralCallbackFlow:
+ def test_callback_propagates_through_passthrough_param(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.extract.extract_names",
+ "proj.pkg.driver.Driver.resolve",
+ ) in calls, calls
diff --git a/codebase_rag/tests/test_java_containment_oracle.py b/codebase_rag/tests/test_java_containment_oracle.py
new file mode 100644
index 000000000..297e7ffea
--- /dev/null
+++ b/codebase_rag/tests/test_java_containment_oracle.py
@@ -0,0 +1,70 @@
+# (H) Covers Java containment-edge validation: cgr's DEFINES (file module ->
+# (H) every named type, including nested) and DEFINES_METHOD (class/interface/
+# (H) enum -> method) edges are graded against the independent JDK Compiler Tree
+# (H) API oracle, joined on (kind, file, line). Exercises an interface method, an
+# (H) enum method, and a nested class (cgr keeps type containment flat).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_java_graph
+from evals.oracles import java_available, run_java_oracle
+from evals.score import score_edge_types
+
+JAVA_SRC = """\
+package demo;
+
+public interface Shape {
+ double area();
+}
+
+public enum Color {
+ RED, GREEN;
+ public int rank() { return 1; }
+}
+
+public class Point implements Shape {
+ private int x;
+ public double area() { return 1.0; }
+
+ public static class Inner {
+ public void helper() {}
+ }
+}
+"""
+
+
+def _require_java() -> None:
+ if not java_available():
+ pytest.skip("java toolchain not available")
+ if cs.SupportedLanguage.JAVA not in load_parsers()[0]:
+ pytest.skip("java parser not available")
+
+
+def test_cgr_matches_jdk_oracle_on_containment_edges(tmp_path: Path) -> None:
+ _require_java()
+ project = tmp_path / "java_edge_test"
+ project.mkdir()
+ (project / "Demo.java").write_text(JAVA_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_java_graph(project, project.name)
+ oracle = run_java_oracle(project)
+
+ result = score_edge_types(cgr, oracle, ec.SCORED_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in (
+ cs.RelationshipType.DEFINES.value,
+ cs.RelationshipType.DEFINES_METHOD.value,
+ ):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (
+ label,
+ row,
+ result.diff,
+ )
diff --git a/codebase_rag/tests/test_java_field_access_chains.py b/codebase_rag/tests/test_java_field_access_chains.py
new file mode 100644
index 000000000..55a1d0791
--- /dev/null
+++ b/codebase_rag/tests/test_java_field_access_chains.py
@@ -0,0 +1,389 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import tree_sitter_java as tsjava
+from tree_sitter import Language, Node, Parser
+
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.parsers.java.utils import extract_class_info
+from codebase_rag.tests.conftest import get_relationships
+
+
+def _call_targets(mock_ingestor: MagicMock) -> set[str]:
+ return {c.args[2][2] for c in get_relationships(mock_ingestor, "CALLS")}
+
+
+def _class_node(java_source: str) -> Node:
+ tree = Parser(Language(tsjava.language())).parse(java_source.encode())
+
+ def walk(node: Node) -> Node | None:
+ if node.type == "class_declaration":
+ return node
+ for child in node.children:
+ if found := walk(child):
+ return found
+ return None
+
+ found = walk(tree.root_node)
+ assert found is not None
+ return found
+
+
+def _run(project_path: Path, mock_ingestor: MagicMock) -> None:
+ parsers, queries = load_parsers()
+ GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=project_path,
+ parsers=parsers,
+ queries=queries,
+ ).run()
+
+
+def test_mixed_field_access_then_method_resolves(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class Engine { public void start() { System.out.println("started"); } }
+class Car { public Engine engine = new Engine(); }
+public class Main {
+ public static void main(String[] args) {
+ Car obj = new Car();
+ obj.engine.start();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".Engine.start()") for t in targets), (
+ f"obj.engine.start() should resolve to Engine.start(); got {sorted(targets)}"
+ )
+
+
+def test_multilevel_field_access_then_method_resolves(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+class User { public Address address = new Address(); }
+public class Main {
+ public static void main(String[] args) {
+ User obj = new User();
+ obj.address.city.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"obj.address.city.ping() should resolve to City.ping(); got {sorted(targets)}"
+ )
+
+
+def test_nested_field_access_type_inference_via_var(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+class User { public Address address = new Address(); }
+public class Main {
+ public static void main(String[] args) {
+ User obj = new User();
+ var c = obj.address.city;
+ c.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"var c = obj.address.city; c.ping() should resolve to City.ping(); "
+ f"got {sorted(targets)}"
+ )
+
+
+def test_this_rooted_nested_field_access_via_var(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+public class Container {
+ public Address address = new Address();
+ public void run() {
+ var c = this.address.city;
+ c.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"var c = this.address.city; c.ping() should resolve to City.ping(); "
+ f"got {sorted(targets)}"
+ )
+
+
+def test_super_rooted_nested_field_access_via_var(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+class Base { public Address address = new Address(); }
+public class Derived extends Base {
+ public void run() {
+ var c = super.address.city;
+ c.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"var c = super.address.city; c.ping() should resolve to City.ping(); "
+ f"got {sorted(targets)}"
+ )
+
+
+def test_inherited_field_chain_via_this(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+class Base { public Address address = new Address(); }
+public class Derived extends Base {
+ public void run() {
+ var c = this.address.city;
+ c.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"this.address.city (address inherited from Base) should resolve to "
+ f"City.ping(); got {sorted(targets)}"
+ )
+
+
+def test_inherited_field_chain_via_object(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+class Base { public Address address = new Address(); }
+class Derived extends Base {}
+public class Main {
+ public static void main(String[] args) {
+ Derived obj = new Derived();
+ obj.address.city.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"obj.address.city (address inherited from Base) should resolve to "
+ f"City.ping(); got {sorted(targets)}"
+ )
+
+
+def test_direct_this_field_chain_method_call_multiclass(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class Aardvark { public void unused() {} }
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+public class Container {
+ public Address address = new Address();
+ public void run() {
+ this.address.city.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"direct this.address.city.ping() in a multi-class file should resolve to "
+ f"City.ping(); got {sorted(targets)}"
+ )
+
+
+def test_direct_super_field_chain_method_call_multiclass(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class Aardvark { public void unused() {} }
+class Other {}
+class Wrong extends Other { public void unused() {} }
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+class Base { public Address address = new Address(); }
+public class Derived extends Base {
+ public void run() {
+ super.address.city.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"direct super.address.city.ping() in a multi-class file should resolve to "
+ f"City.ping(); got {sorted(targets)}"
+ )
+
+
+def test_scoped_superclass_extraction_keeps_actual_class() -> None:
+ nested = extract_class_info(_class_node("class Child extends Outer.Base {}"))
+ assert nested.get("superclass") == "Outer.Base", (
+ f"scoped superclass should keep the full name, not the outer/package "
+ f"segment; got {nested.get('superclass')!r}"
+ )
+
+ qualified = extract_class_info(_class_node("class Child extends pkg.Base {}"))
+ assert qualified.get("superclass") == "pkg.Base", (
+ f"package-qualified superclass should keep the full name; "
+ f"got {qualified.get('superclass')!r}"
+ )
+
+ simple = extract_class_info(_class_node("class Child extends Base {}"))
+ assert simple.get("superclass") == "Base"
+
+
+def test_inherited_field_chain_via_nested_superclass(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+class Outer {
+ static class Base { public Address address = new Address(); }
+}
+public class Child extends Outer.Base {
+ public void run() {
+ this.address.city.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"this.address.city with a same-file nested superclass (Outer.Base) should "
+ f"resolve to City.ping(); got {sorted(targets)}"
+ )
+
+
+def test_super_rooted_chain_with_nested_superclass(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "proj"
+ (project / "src").mkdir(parents=True)
+ (project / "src" / "Main.java").write_text(
+ """
+class City { public void ping() { System.out.println("ping"); } }
+class Address { public City city = new City(); }
+class Outer {
+ static class Base { public Address address = new Address(); }
+}
+public class Child extends Outer.Base {
+ public void run() {
+ var c = super.address.city;
+ c.ping();
+ }
+}
+""",
+ encoding="utf-8",
+ )
+ _run(project, mock_ingestor)
+
+ targets = _call_targets(mock_ingestor)
+ assert any(t.endswith(".City.ping()") for t in targets), (
+ f"super.address.city with a nested superclass (Outer.Base) should resolve to "
+ f"City.ping(); got {sorted(targets)}"
+ )
+
+
+def test_generic_scoped_superclass_extraction() -> None:
+ generic_scoped = extract_class_info(
+ _class_node("class Child extends Outer.Base {}")
+ )
+ assert generic_scoped.get("superclass") == "Outer.Base", (
+ f"generic scoped superclass should extract the base name; "
+ f"got {generic_scoped.get('superclass')!r}"
+ )
+
+ generic_simple = extract_class_info(
+ _class_node("class Child extends Box {}")
+ )
+ assert generic_simple.get("superclass") == "Box", (
+ f"generic superclass should extract the base name; "
+ f"got {generic_simple.get('superclass')!r}"
+ )
diff --git a/codebase_rag/tests/test_java_inheritance_edges.py b/codebase_rag/tests/test_java_inheritance_edges.py
new file mode 100644
index 000000000..9c293833f
--- /dev/null
+++ b/codebase_rag/tests/test_java_inheritance_edges.py
@@ -0,0 +1,59 @@
+# (H) Java inheritance edges. cgr captured a class's `extends`/`implements` but
+# (H) missed two cases: an interface's `extends` superinterfaces (-> INHERITS)
+# (H) and an enum's `implements` interfaces (-> IMPLEMENTS). Both clauses carry a
+# (H) type_list of interface names that were never extracted.
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.constants import RelationshipType
+from codebase_rag.tests.conftest import create_and_run_updater, get_relationships
+
+_JAVA = """\
+package demo;
+
+public interface A {}
+public interface B {}
+public interface Big extends A, B {}
+
+abstract class Base {}
+enum Color implements A { RED }
+
+class Circle extends Base implements A, B {}
+
+class Holder extends Box implements Comparable {}
+"""
+
+
+def _pairs(mock_ingestor: MagicMock, rel: str) -> set[tuple[str, str]]:
+ # (H) (source_qn, target_qn) for the given relationship.
+ return {
+ (call[0][0][2], call[0][2][2]) for call in get_relationships(mock_ingestor, rel)
+ }
+
+
+def test_java_inheritance_and_implements_edges(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "java_inh"
+ project.mkdir()
+ (project / "Demo.java").write_text(_JAVA, encoding="utf-8")
+ create_and_run_updater(project, mock_ingestor, skip_if_missing="java")
+
+ inherits = _pairs(mock_ingestor, RelationshipType.INHERITS.value)
+ implements = _pairs(mock_ingestor, RelationshipType.IMPLEMENTS.value)
+ base = "java_inh.Demo"
+
+ # (H) Interface extends -> INHERITS to each superinterface.
+ assert (f"{base}.Big", f"{base}.A") in inherits, inherits
+ assert (f"{base}.Big", f"{base}.B") in inherits, inherits
+ # (H) Enum implements -> IMPLEMENTS.
+ assert (f"{base}.Color", f"{base}.A") in implements, implements
+ # (H) Class extends/implements (already worked) stay intact.
+ assert (f"{base}.Circle", f"{base}.Base") in inherits, inherits
+ assert (f"{base}.Circle", f"{base}.A") in implements, implements
+ assert (f"{base}.Circle", f"{base}.B") in implements, implements
+ # (H) Generic (parameterized) bases must be captured by their base type.
+ assert (f"{base}.Holder", f"{base}.Box") in inherits, inherits
+ assert (f"{base}.Holder", f"{base}.Comparable") in implements, implements
diff --git a/codebase_rag/tests/test_java_inheritance_oracle.py b/codebase_rag/tests/test_java_inheritance_oracle.py
new file mode 100644
index 000000000..65b8c2f42
--- /dev/null
+++ b/codebase_rag/tests/test_java_inheritance_oracle.py
@@ -0,0 +1,59 @@
+# (H) Covers Java inheritance-edge validation: cgr's INHERITS (class/interface
+# (H) extends) and IMPLEMENTS (class/enum implements) edges are graded against the
+# (H) JDK Compiler Tree API oracle, by (source node, base SIMPLE NAME).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_java_graph
+from evals.oracles import java_available, run_java_oracle
+from evals.score import score_name_edge_types
+
+JAVA_SRC = """\
+package demo;
+
+public interface A {}
+public interface B {}
+public interface Big extends A, B {}
+
+abstract class Base {}
+enum Color implements A { RED }
+
+class Circle extends Base implements A, B {}
+"""
+
+
+def _require_java() -> None:
+ if not java_available():
+ pytest.skip("java toolchain not available")
+ if cs.SupportedLanguage.JAVA not in load_parsers()[0]:
+ pytest.skip("java parser not available")
+
+
+def test_cgr_matches_jdk_oracle_on_inheritance_edges(tmp_path: Path) -> None:
+ _require_java()
+ project = tmp_path / "java_inh_edge"
+ project.mkdir()
+ (project / "Demo.java").write_text(JAVA_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_java_graph(project, project.name)
+ oracle = run_java_oracle(project)
+
+ result = score_name_edge_types(cgr, oracle, ec.INHERITANCE_NAME_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in (
+ cs.RelationshipType.INHERITS.value,
+ cs.RelationshipType.IMPLEMENTS.value,
+ ):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (
+ label,
+ row,
+ result.diff,
+ )
diff --git a/codebase_rag/tests/test_java_label_name_collision.py b/codebase_rag/tests/test_java_label_name_collision.py
new file mode 100644
index 000000000..c43702119
--- /dev/null
+++ b/codebase_rag/tests/test_java_label_name_collision.py
@@ -0,0 +1,314 @@
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag.constants import NODE_UNIQUE_CONSTRAINTS, NodeLabel
+from codebase_rag.tests.conftest import (
+ get_node_names,
+ get_nodes,
+ get_qualified_names,
+ get_relationships,
+ run_updater,
+)
+from codebase_rag.types_defs import NodeType
+
+
+@pytest.fixture
+def java_label_collision_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "java_label_collision"
+ project_path.mkdir()
+ src = project_path / "src" / "main" / "java" / "com" / "example"
+ src.mkdir(parents=True)
+ return project_path
+
+
+def _src_dir(project: Path) -> Path:
+ return project / "src" / "main" / "java" / "com" / "example"
+
+
+def _has_qn_ending(qns: set[str], suffix: str) -> bool:
+ return any(qn.endswith(suffix) for qn in qns)
+
+
+def test_interface_named_interface_ingested_as_interface_node(
+ java_label_collision_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ src = _src_dir(java_label_collision_project)
+ (src / "Interface.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public interface Interface {
+ void doSomething();
+}
+""",
+ )
+ run_updater(java_label_collision_project, mock_ingestor, skip_if_missing="java")
+
+ interface_nodes = get_nodes(mock_ingestor, NodeType.INTERFACE)
+ interface_qns = get_qualified_names(interface_nodes)
+
+ assert _has_qn_ending(interface_qns, ".Interface"), (
+ f"Interface named 'Interface' not found in Interface nodes. Got: {interface_qns}"
+ )
+
+ class_qns = get_node_names(mock_ingestor, NodeType.CLASS)
+ interface_in_class = [qn for qn in class_qns if qn.endswith(".Interface")]
+ assert not interface_in_class, (
+ f"Interface named 'Interface' should not appear as a Class node. Got: {interface_in_class}"
+ )
+
+
+def test_enum_named_enum_ingested_as_enum_node(
+ java_label_collision_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ src = _src_dir(java_label_collision_project)
+ (src / "Enum.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public enum Enum {
+ VALUE_A,
+ VALUE_B,
+ VALUE_C
+}
+""",
+ )
+ run_updater(java_label_collision_project, mock_ingestor, skip_if_missing="java")
+
+ enum_nodes = get_nodes(mock_ingestor, NodeType.ENUM)
+ enum_qns = get_qualified_names(enum_nodes)
+
+ assert _has_qn_ending(enum_qns, ".Enum"), (
+ f"Enum named 'Enum' not found in Enum nodes. Got: {enum_qns}"
+ )
+
+ class_qns = get_node_names(mock_ingestor, NodeType.CLASS)
+ enum_in_class = [qn for qn in class_qns if qn.endswith(".Enum")]
+ assert not enum_in_class, (
+ f"Enum named 'Enum' should not appear as a Class node. Got: {enum_in_class}"
+ )
+
+
+def test_class_named_class_ingested_as_class_node(
+ java_label_collision_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ src = _src_dir(java_label_collision_project)
+ (src / "Class.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public class Class {
+ public void run() {}
+}
+""",
+ )
+ run_updater(java_label_collision_project, mock_ingestor, skip_if_missing="java")
+
+ class_nodes = get_nodes(mock_ingestor, NodeType.CLASS)
+ class_qns = get_qualified_names(class_nodes)
+
+ assert _has_qn_ending(class_qns, ".Class"), (
+ f"Class named 'Class' not found in Class nodes. Got: {class_qns}"
+ )
+
+
+def test_interface_and_enum_labels_have_constraints() -> None:
+ assert NodeLabel.INTERFACE in NODE_UNIQUE_CONSTRAINTS, (
+ "Interface label missing from NODE_UNIQUE_CONSTRAINTS"
+ )
+ assert NodeLabel.ENUM in NODE_UNIQUE_CONSTRAINTS, (
+ "Enum label missing from NODE_UNIQUE_CONSTRAINTS"
+ )
+ assert NODE_UNIQUE_CONSTRAINTS[NodeLabel.INTERFACE] == "qualified_name"
+ assert NODE_UNIQUE_CONSTRAINTS[NodeLabel.ENUM] == "qualified_name"
+
+
+def test_all_node_labels_have_constraints() -> None:
+ for label in NodeLabel:
+ assert label.value in NODE_UNIQUE_CONSTRAINTS, (
+ f"NodeLabel.{label.name} ('{label.value}') missing from NODE_UNIQUE_CONSTRAINTS"
+ )
+
+
+def test_interface_named_interface_has_defines_relationship(
+ java_label_collision_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ src = _src_dir(java_label_collision_project)
+ (src / "Interface.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public interface Interface {
+ void doSomething();
+}
+""",
+ )
+ run_updater(java_label_collision_project, mock_ingestor, skip_if_missing="java")
+
+ defines_rels = get_relationships(mock_ingestor, "DEFINES")
+ found_defines = False
+ for rel in defines_rels:
+ if len(rel.args) >= 3:
+ to_spec = rel.args[2]
+ if isinstance(to_spec, tuple) and len(to_spec) >= 3:
+ to_label = to_spec[0]
+ to_qn = str(to_spec[2])
+ if to_qn.endswith(".Interface"):
+ assert to_label == NodeType.INTERFACE, (
+ f"DEFINES target label should be 'Interface', got '{to_label}'"
+ )
+ found_defines = True
+
+ assert found_defines, (
+ "No DEFINES relationship found for Interface named 'Interface'"
+ )
+
+
+def test_enum_named_enum_has_defines_relationship(
+ java_label_collision_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ src = _src_dir(java_label_collision_project)
+ (src / "Enum.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public enum Enum {
+ VALUE_A,
+ VALUE_B
+}
+""",
+ )
+ run_updater(java_label_collision_project, mock_ingestor, skip_if_missing="java")
+
+ defines_rels = get_relationships(mock_ingestor, "DEFINES")
+ found_defines = False
+ for rel in defines_rels:
+ if len(rel.args) >= 3:
+ to_spec = rel.args[2]
+ if isinstance(to_spec, tuple) and len(to_spec) >= 3:
+ to_label = to_spec[0]
+ to_qn = str(to_spec[2])
+ if to_qn.endswith(".Enum"):
+ assert to_label == NodeType.ENUM, (
+ f"DEFINES target label should be 'Enum', got '{to_label}'"
+ )
+ found_defines = True
+
+ assert found_defines, "No DEFINES relationship found for Enum named 'Enum'"
+
+
+def test_class_implementing_interface_named_interface(
+ java_label_collision_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ src = _src_dir(java_label_collision_project)
+ (src / "Interface.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public interface Interface {
+ void doSomething();
+}
+""",
+ )
+ (src / "Implementor.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public class Implementor implements Interface {
+ public void doSomething() {
+ System.out.println("done");
+ }
+}
+""",
+ )
+ run_updater(java_label_collision_project, mock_ingestor, skip_if_missing="java")
+
+ interface_qns = get_node_names(mock_ingestor, NodeType.INTERFACE)
+ assert _has_qn_ending(interface_qns, ".Interface")
+
+ class_qns = get_node_names(mock_ingestor, NodeType.CLASS)
+ assert _has_qn_ending(class_qns, ".Implementor")
+
+ implements_rels = get_relationships(mock_ingestor, "IMPLEMENTS")
+ found_implements = False
+ for rel in implements_rels:
+ if len(rel.args) >= 3:
+ from_spec = rel.args[0]
+ if isinstance(from_spec, tuple) and len(from_spec) >= 3:
+ from_qn = str(from_spec[2])
+ if from_qn.endswith(".Implementor"):
+ found_implements = True
+
+ assert found_implements, (
+ "No IMPLEMENTS relationship found for Implementor -> Interface"
+ )
+
+
+def test_multiple_label_colliding_names(
+ java_label_collision_project: Path,
+ mock_ingestor: MagicMock,
+) -> None:
+ src = _src_dir(java_label_collision_project)
+ (src / "Function.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public class Function {
+ public void execute() {}
+}
+""",
+ )
+ (src / "Method.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public class Method {
+ public void invoke() {}
+}
+""",
+ )
+ (src / "Module.java").write_text(
+ encoding="utf-8",
+ data="""\
+package com.example;
+
+public class Module {
+ public void load() {}
+}
+""",
+ )
+ run_updater(java_label_collision_project, mock_ingestor, skip_if_missing="java")
+
+ class_qns = get_node_names(mock_ingestor, NodeType.CLASS)
+ assert _has_qn_ending(class_qns, ".Function")
+ assert _has_qn_ending(class_qns, ".Method")
+ assert _has_qn_ending(class_qns, ".Module")
+
+ function_qns = get_node_names(mock_ingestor, NodeType.FUNCTION)
+ method_qns = get_node_names(mock_ingestor, NodeType.METHOD)
+ non_class_qns = function_qns | method_qns
+ collisions = [
+ qn
+ for qn in non_class_qns
+ if qn.endswith(".Function") or qn.endswith(".Method") or qn.endswith(".Module")
+ ]
+ assert not collisions, (
+ f"Class names colliding with node labels should not appear as wrong node types: {collisions}"
+ )
diff --git a/codebase_rag/tests/test_java_span_oracle.py b/codebase_rag/tests/test_java_span_oracle.py
new file mode 100644
index 000000000..8ecff7bbb
--- /dev/null
+++ b/codebase_rag/tests/test_java_span_oracle.py
@@ -0,0 +1,74 @@
+# (H) Covers Java node SPAN (end_line) validation: cgr's end_line for each node is
+# (H) graded against the JDK Compiler Tree API oracle (which emits each node's
+# (H) source end position), joined on (kind, file, start). Exercises a class with a
+# (H) multi-line method signature, an interface, an enum, and a nested class so
+# (H) spans are not trivially single line.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_java_graph
+from evals.oracles import java_available, run_java_oracle
+from evals.score import score_span
+
+JAVA_SRC = """\
+package demo;
+
+public class Widget implements Shape {
+ private int size;
+
+ public int area(
+ int scale
+ ) {
+ return this.size * scale;
+ }
+
+ static class Inner {
+ int value() {
+ return 1;
+ }
+ }
+}
+
+interface Shape {
+ int area(int scale);
+}
+
+enum Color {
+ RED,
+ GREEN,
+ BLUE
+}
+"""
+
+
+def _require_java() -> None:
+ if not java_available():
+ pytest.skip("jdk (javac/java) not available")
+ if cs.SupportedLanguage.JAVA not in load_parsers()[0]:
+ pytest.skip("java parser not available")
+
+
+def test_cgr_matches_jdk_oracle_on_node_spans(tmp_path: Path) -> None:
+ _require_java()
+ project = tmp_path / "java_span_test"
+ (project / "demo").mkdir(parents=True)
+ (project / "demo" / "Widget.java").write_text(JAVA_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_java_graph(project, project.name)
+ oracle = run_java_oracle(project)
+
+ result = score_span(cgr, oracle, ec.JAVA_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ aggregate = by_label.get(ec.AGGREGATE_LABEL)
+ assert aggregate is not None, (by_label, result.diff)
+ assert aggregate["precision"] == 1.0 and aggregate["recall"] == 1.0, (
+ aggregate,
+ result.diff,
+ )
+ assert aggregate["tp"] >= 5, aggregate
diff --git a/codebase_rag/tests/test_java_structure_oracle.py b/codebase_rag/tests/test_java_structure_oracle.py
new file mode 100644
index 000000000..2c1db2004
--- /dev/null
+++ b/codebase_rag/tests/test_java_structure_oracle.py
@@ -0,0 +1,72 @@
+# (H) Covers the Java structure oracle harness (evals/oracles/java_oracle +
+# (H) evals/java_l1.py): the JDK Compiler Tree API oracle is authoritative ground
+# (H) truth, and cgr's captured Java nodes are graded against it on
+# (H) (kind, file, start_line). Includes an anonymous class, whose methods cgr
+# (H) models as standalone Functions (like JS object-literal methods).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_java_nodes
+from evals.oracles import java_available, run_java_oracle
+from evals.score import score_node_kinds
+from evals.types_defs import GraphData
+
+JAVA_SRC = """\
+package demo;
+
+public class Sample {
+ private int x;
+ public Sample(int x) { this.x = x; }
+ public int area() { return x; }
+ public static Sample make(int x) { return new Sample(x); }
+
+ interface Shape { double area(); }
+ enum Color { RED, GREEN }
+ static class Inner { void helper() {} }
+
+ Runnable callback() {
+ return new Runnable() {
+ public void run() { helper2(); }
+ void helper2() {}
+ };
+ }
+}
+
+interface Drawable { void draw(); }
+
+enum Direction { NORTH, SOUTH }
+"""
+
+
+def _require_java() -> None:
+ if not java_available():
+ pytest.skip("javac/java toolchain not available")
+ if cs.SupportedLanguage.JAVA not in load_parsers()[0]:
+ pytest.skip("java parser not available")
+
+
+def test_cgr_matches_jdk_oracle_on_java_structure(tmp_path: Path) -> None:
+ _require_java()
+ project = tmp_path / "java_oracle_test"
+ project.mkdir()
+ (project / "Sample.java").write_text(JAVA_SRC, encoding="utf-8")
+
+ cgr = GraphData(
+ nodes=extract_cgr_java_nodes(project, project.name),
+ edges=set(),
+ name_edges=set(),
+ )
+ oracle = run_java_oracle(project)
+
+ result = score_node_kinds(cgr, oracle, ec.JAVA_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in ("Class", "Interface", "Enum", "Method", "Function"):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (label, row)
diff --git a/codebase_rag/tests/test_javascript_containment_oracle.py b/codebase_rag/tests/test_javascript_containment_oracle.py
new file mode 100644
index 000000000..bc197d92b
--- /dev/null
+++ b/codebase_rag/tests/test_javascript_containment_oracle.py
@@ -0,0 +1,56 @@
+# (H) Covers JavaScript containment-edge validation: cgr's DEFINES (file module
+# (H) -> class / top-level function) and DEFINES_METHOD (class -> method) edges
+# (H) are graded against the TypeScript-compiler-API oracle run over .js, joined
+# (H) on (kind, file, line).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_js_graph
+from evals.oracles import run_javascript_oracle, typescript_available
+from evals.score import score_edge_types
+
+JS_SRC = """\
+export class Point {
+ constructor() { this.x = 0; }
+ area() { return 1.0; }
+}
+
+export function free() { return 1; }
+"""
+
+
+def _require_js() -> None:
+ if not typescript_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.JS not in load_parsers()[0]:
+ pytest.skip("javascript parser not available")
+
+
+def test_cgr_matches_tsc_oracle_on_js_containment_edges(tmp_path: Path) -> None:
+ _require_js()
+ project = tmp_path / "js_edge"
+ project.mkdir()
+ (project / "lib.js").write_text(JS_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_js_graph(project, project.name)
+ oracle = run_javascript_oracle(project)
+
+ result = score_edge_types(cgr, oracle, ec.SCORED_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in (
+ cs.RelationshipType.DEFINES.value,
+ cs.RelationshipType.DEFINES_METHOD.value,
+ ):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (
+ label,
+ row,
+ result.diff,
+ )
diff --git a/codebase_rag/tests/test_javascript_span_oracle.py b/codebase_rag/tests/test_javascript_span_oracle.py
new file mode 100644
index 000000000..49a64333b
--- /dev/null
+++ b/codebase_rag/tests/test_javascript_span_oracle.py
@@ -0,0 +1,65 @@
+# (H) Covers JavaScript node SPAN (end_line) validation: cgr's end_line for each
+# (H) node is graded against the TS-compiler-API oracle run over .js (which emits
+# (H) each node's full-span end line), joined on (kind, file, start). Exercises a
+# (H) class with a multi-line method signature, a multi-line arrow assigned to a
+# (H) const, and a nested arrow so spans are not trivially single line.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_js_graph
+from evals.oracles import run_javascript_oracle, typescript_available
+from evals.score import score_span
+
+JS_SRC = """\
+class Widget {
+ area(
+ scale,
+ ) {
+ return scale;
+ }
+}
+
+function standalone() {
+ const cb = (v) => {
+ return v + 1;
+ };
+ return cb(2);
+}
+
+const arrow = (x) => {
+ return x * 2;
+};
+"""
+
+
+def _require_js() -> None:
+ if not typescript_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.JS not in load_parsers()[0]:
+ pytest.skip("javascript parser not available")
+
+
+def test_cgr_matches_tsc_oracle_on_javascript_node_spans(tmp_path: Path) -> None:
+ _require_js()
+ project = tmp_path / "js_span_test"
+ project.mkdir()
+ (project / "main.js").write_text(JS_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_js_graph(project, project.name)
+ oracle = run_javascript_oracle(project)
+
+ result = score_span(cgr, oracle, ec.JS_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ aggregate = by_label.get(ec.AGGREGATE_LABEL)
+ assert aggregate is not None, (by_label, result.diff)
+ assert aggregate["precision"] == 1.0 and aggregate["recall"] == 1.0, (
+ aggregate,
+ result.diff,
+ )
+ assert aggregate["tp"] >= 4, aggregate
diff --git a/codebase_rag/tests/test_javascript_structure_oracle.py b/codebase_rag/tests/test_javascript_structure_oracle.py
new file mode 100644
index 000000000..508326d0d
--- /dev/null
+++ b/codebase_rag/tests/test_javascript_structure_oracle.py
@@ -0,0 +1,57 @@
+# (H) Covers the JavaScript structure oracle harness (evals/oracles/ts_oracle run
+# (H) over .js/.jsx + evals/js_l1.py): the TS-compiler-API oracle is authoritative
+# (H) ground truth, and cgr's captured JavaScript nodes are graded against it on
+# (H) (kind, file, start_line).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_js_nodes
+from evals.oracles import run_javascript_oracle, typescript_available
+from evals.score import score_node_kinds
+from evals.types_defs import GraphData
+
+JS_SRC = """\
+class Point {
+ constructor(x) { this.x = x; }
+ area() { return this.x; }
+}
+
+function freeFn(a) { return a + 1; }
+const arrow = (b) => b * 2;
+const obj = { method() { return 1; } };
+[1, 2].forEach((n) => freeFn(n));
+"""
+
+
+def _require_js() -> None:
+ if not typescript_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.JS not in load_parsers()[0]:
+ pytest.skip("javascript parser not available")
+
+
+def test_cgr_matches_tsc_oracle_on_javascript_structure(tmp_path: Path) -> None:
+ _require_js()
+ project = tmp_path / "js_oracle_test"
+ project.mkdir()
+ (project / "app.js").write_text(JS_SRC, encoding="utf-8")
+
+ cgr = GraphData(
+ nodes=extract_cgr_js_nodes(project, project.name),
+ edges=set(),
+ name_edges=set(),
+ )
+ oracle = run_javascript_oracle(project)
+
+ result = score_node_kinds(cgr, oracle, ec.JS_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in ("Class", "Function", "Method"):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (label, row)
diff --git a/codebase_rag/tests/test_js_ts_utils_integration.py b/codebase_rag/tests/test_js_ts_utils_integration.py
index d83ccf4ae..bc50fb53b 100644
--- a/codebase_rag/tests/test_js_ts_utils_integration.py
+++ b/codebase_rag/tests/test_js_ts_utils_integration.py
@@ -647,6 +647,78 @@ def test_deeply_nested_qn(self) -> None:
assert result == "a.b.c.d.e"
+@pytest.mark.skipif(not JS_AVAILABLE, reason="tree-sitter-javascript not available")
+class TestFindMethodInAstCacheOwnerTracking:
+ def test_cache_invalidates_on_new_root_node(
+ self, js_parser: Parser, sample_js_project: Path
+ ) -> None:
+ from codebase_rag.parsers.js_ts import utils as js_utils
+
+ tree1 = parse_file(js_parser, sample_js_project / "singleton.js")
+ root1 = tree1.root_node
+ result1 = find_method_in_ast(root1, "DatabaseConnection", "getInstance")
+ assert result1 is not None
+ owner_after_first = js_utils._CLASS_BODY_CACHE_OWNER
+
+ tree2 = parse_file(js_parser, sample_js_project / "factory.js")
+ root2 = tree2.root_node
+ result2 = find_method_in_ast(root2, "Dog", "speak")
+ assert result2 is not None
+ owner_after_second = js_utils._CLASS_BODY_CACHE_OWNER
+
+ assert owner_after_first != owner_after_second
+
+ def test_cache_hit_returns_correct_result(
+ self, js_parser: Parser, sample_js_project: Path
+ ) -> None:
+ tree = parse_file(js_parser, sample_js_project / "factory.js")
+ root = tree.root_node
+
+ result1 = find_method_in_ast(root, "Dog", "speak")
+ assert result1 is not None
+
+ result2 = find_method_in_ast(root, "Dog", "fetch")
+ assert result2 is not None
+
+ def test_cache_miss_returns_none(
+ self, js_parser: Parser, sample_js_project: Path
+ ) -> None:
+ tree = parse_file(js_parser, sample_js_project / "factory.js")
+ root = tree.root_node
+
+ result = find_method_in_ast(root, "NonExistent", "method")
+ assert result is None
+
+ result2 = find_method_in_ast(root, "NonExistent", "other")
+ assert result2 is None
+
+
+@pytest.mark.skipif(not JS_AVAILABLE, reason="tree-sitter-javascript not available")
+class TestFindReturnStatementsWithLanguageObj:
+ def test_with_language_obj(
+ self, js_parser: Parser, sample_js_project: Path
+ ) -> None:
+ tree = parse_file(js_parser, sample_js_project / "complex_returns.js")
+ set_name = find_method_in_ast(tree.root_node, "Builder", "setName")
+ assert set_name is not None
+
+ language = Language(tsjs.language())
+ return_nodes: list = []
+ find_return_statements(set_name, return_nodes, language)
+ assert len(return_nodes) == 1
+
+ def test_fallback_without_language_obj(
+ self, js_parser: Parser, sample_js_project: Path
+ ) -> None:
+ tree = parse_file(js_parser, sample_js_project / "complex_returns.js")
+ set_name = find_method_in_ast(tree.root_node, "Builder", "setName")
+ assert set_name is not None
+
+ return_nodes: list = []
+ find_return_statements(set_name, return_nodes, None)
+ assert len(return_nodes) == 1
+
+
@pytest.mark.skipif(not TS_AVAILABLE, reason="tree-sitter-typescript not available")
class TestTypeScriptIntegration:
def test_find_generic_class_methods(
diff --git a/codebase_rag/tests/test_js_type_inference_unit.py b/codebase_rag/tests/test_js_type_inference_unit.py
index 21e008522..279ac8b7f 100644
--- a/codebase_rag/tests/test_js_type_inference_unit.py
+++ b/codebase_rag/tests/test_js_type_inference_unit.py
@@ -428,3 +428,89 @@ def test_variable_with_uninferrable_value_is_skipped(
)
assert result == {}
+
+
+class TestGetDeclaratorsViaQueryException:
+ def test_returns_none_when_queries_is_none(
+ self,
+ mock_import_processor: MagicMock,
+ mock_function_registry: MagicMock,
+ mock_find_method_ast_node: MagicMock,
+ ) -> None:
+ engine = JsTypeInferenceEngine(
+ import_processor=mock_import_processor,
+ function_registry=mock_function_registry,
+ project_name="test_project",
+ find_method_ast_node_func=mock_find_method_ast_node,
+ queries=None,
+ )
+ root_node = create_mock_node("program", children=[])
+ result = engine._get_declarators_via_query(
+ root_node, # ty: ignore[invalid-argument-type] # (H) MockNode not Node
+ )
+ assert result is None
+
+ def test_exception_in_query_continues_to_next_language(
+ self,
+ mock_import_processor: MagicMock,
+ mock_function_registry: MagicMock,
+ mock_find_method_ast_node: MagicMock,
+ ) -> None:
+ bad_language_obj = MagicMock()
+ bad_language_obj.side_effect = Exception("bad query")
+
+ queries = {
+ cs.SupportedLanguage.JS: {"language": bad_language_obj},
+ cs.SupportedLanguage.TS: {"language": bad_language_obj},
+ }
+
+ engine = JsTypeInferenceEngine(
+ import_processor=mock_import_processor,
+ function_registry=mock_function_registry,
+ project_name="test_project",
+ find_method_ast_node_func=mock_find_method_ast_node,
+ queries=queries,
+ )
+ root_node = create_mock_node("program", children=[])
+ result = engine._get_declarators_via_query(
+ root_node, # ty: ignore[invalid-argument-type] # (H) MockNode not Node
+ )
+ assert result is None
+
+
+class TestGetLanguageObj:
+ def test_returns_none_when_queries_is_none(
+ self,
+ mock_import_processor: MagicMock,
+ mock_function_registry: MagicMock,
+ mock_find_method_ast_node: MagicMock,
+ ) -> None:
+ engine = JsTypeInferenceEngine(
+ import_processor=mock_import_processor,
+ function_registry=mock_function_registry,
+ project_name="test_project",
+ find_method_ast_node_func=mock_find_method_ast_node,
+ queries=None,
+ )
+ result = engine._get_language_obj()
+ assert result is None
+
+ def test_returns_language_when_available(
+ self,
+ mock_import_processor: MagicMock,
+ mock_function_registry: MagicMock,
+ mock_find_method_ast_node: MagicMock,
+ ) -> None:
+ lang_obj = MagicMock()
+ queries = {
+ cs.SupportedLanguage.JS: {"language": lang_obj},
+ }
+ engine = JsTypeInferenceEngine(
+ import_processor=mock_import_processor,
+ function_registry=mock_function_registry,
+ project_name="test_project",
+ find_method_ast_node_func=mock_find_method_ast_node,
+ queries=queries,
+ )
+ result = engine._get_language_obj()
+ assert result is lang_obj
diff --git a/codebase_rag/tests/test_l3_decorator_normalization.py b/codebase_rag/tests/test_l3_decorator_normalization.py
new file mode 100644
index 000000000..a2e105398
--- /dev/null
+++ b/codebase_rag/tests/test_l3_decorator_normalization.py
@@ -0,0 +1,77 @@
+# (H) Covers the L3 eval harness (evals/calls_trace.py): a call to a functools.wraps
+# (H) decorated function dispatches through the decorator's generic wrapper at runtime,
+# (H) but cgr's static graph resolves the call to the function itself. The trace must
+# (H) attribute the wrapper frame to the wrapped function so the two agree.
+from __future__ import annotations
+
+import importlib.util
+import textwrap
+from pathlib import Path
+
+from evals.calls_trace import trace_calls
+
+MOD_SRC = textwrap.dedent(
+ """
+ from functools import wraps
+
+
+ def guard(fn):
+ @wraps(fn)
+ def wrapper(*args, **kwargs):
+ return fn(*args, **kwargs)
+
+ return wrapper
+
+
+ def helper():
+ return 1
+
+
+ @guard
+ def target_fn():
+ return helper()
+
+
+ def caller():
+ return target_fn()
+ """
+)
+
+
+def _load_module(mod_path: Path):
+ spec = importlib.util.spec_from_file_location("evaltest_decorator_mod", mod_path)
+ assert spec is not None and spec.loader is not None
+ module = importlib.util.module_from_spec(spec)
+ spec.loader.exec_module(module)
+ return module
+
+
+def _trace(tmp_path: Path) -> set[tuple[str, str]]:
+ pkg = tmp_path / "pkgx"
+ pkg.mkdir()
+ (pkg / "__init__.py").write_text("")
+ mod_path = pkg / "mod.py"
+ mod_path.write_text(MOD_SRC)
+ module = _load_module(mod_path)
+ return trace_calls(module.caller, pkg, "pkgx")
+
+
+class TestDecoratorWrapperNormalization:
+ def test_call_attributed_to_wrapped_function_not_wrapper(
+ self, tmp_path: Path
+ ) -> None:
+ edges = _trace(tmp_path)
+ assert ("pkgx.mod.caller", "pkgx.mod.target_fn") in edges, edges
+
+ def test_no_generic_wrapper_node_appears(self, tmp_path: Path) -> None:
+ edges = _trace(tmp_path)
+ wrapper_edges = [
+ (frm, to)
+ for frm, to in edges
+ if frm.endswith("wrapper") or to.endswith("wrapper")
+ ]
+ assert wrapper_edges == [], wrapper_edges
+
+ def test_wrapped_function_body_calls_are_preserved(self, tmp_path: Path) -> None:
+ edges = _trace(tmp_path)
+ assert ("pkgx.mod.target_fn", "pkgx.mod.helper") in edges, edges
diff --git a/codebase_rag/tests/test_language_node_coverage.py b/codebase_rag/tests/test_language_node_coverage.py
index 74648125f..7ee255693 100644
--- a/codebase_rag/tests/test_language_node_coverage.py
+++ b/codebase_rag/tests/test_language_node_coverage.py
@@ -3,8 +3,8 @@
import pytest
from codebase_rag.constants import (
+ C_EXTENSIONS,
CPP_EXTENSIONS,
- CS_EXTENSIONS,
GO_EXTENSIONS,
JAVA_EXTENSIONS,
JS_EXTENSIONS,
@@ -60,8 +60,8 @@ def test_each_language_has_file_extensions(self, lang: SupportedLanguage) -> Non
(SupportedLanguage.GO, GO_EXTENSIONS),
(SupportedLanguage.SCALA, SCALA_EXTENSIONS),
(SupportedLanguage.JAVA, JAVA_EXTENSIONS),
+ (SupportedLanguage.C, C_EXTENSIONS),
(SupportedLanguage.CPP, CPP_EXTENSIONS),
- (SupportedLanguage.CSHARP, CS_EXTENSIONS),
(SupportedLanguage.PHP, PHP_EXTENSIONS),
(SupportedLanguage.LUA, LUA_EXTENSIONS),
]
@@ -87,11 +87,11 @@ def test_language_spec_has_correct_extensions(
(".go", SupportedLanguage.GO),
(".scala", SupportedLanguage.SCALA),
(".java", SupportedLanguage.JAVA),
+ (".c", SupportedLanguage.C),
(".cpp", SupportedLanguage.CPP),
(".h", SupportedLanguage.CPP),
(".hpp", SupportedLanguage.CPP),
(".cc", SupportedLanguage.CPP),
- (".cs", SupportedLanguage.CSHARP),
(".php", SupportedLanguage.PHP),
(".lua", SupportedLanguage.LUA),
]
diff --git a/codebase_rag/tests/test_llm_service_unit.py b/codebase_rag/tests/test_llm_service_unit.py
index 74127c7f5..4fc69287d 100644
--- a/codebase_rag/tests/test_llm_service_unit.py
+++ b/codebase_rag/tests/test_llm_service_unit.py
@@ -231,12 +231,13 @@ def test_creates_agent_with_tools(
mock_agent.return_value = MagicMock()
tools = [MagicMock(), MagicMock()]
- result = create_rag_orchestrator(tools)
+ agent, system_prompt = create_rag_orchestrator(tools)
mock_agent.assert_called_once()
call_kwargs = mock_agent.call_args.kwargs
assert call_kwargs["tools"] == tools
- assert result is not None
+ assert agent is not None
+ assert system_prompt == "System prompt"
@patch("codebase_rag.services.llm.settings")
@patch("codebase_rag.services.llm.get_provider_from_config")
diff --git a/codebase_rag/tests/test_local_alias_calls.py b/codebase_rag/tests/test_local_alias_calls.py
new file mode 100644
index 000000000..017638524
--- /dev/null
+++ b/codebase_rag/tests/test_local_alias_calls.py
@@ -0,0 +1,90 @@
+# (H) L3 finding from the evals/ harness: a function bound to a local variable and
+# (H) then called through that alias (g = self._method; g()) runs the aliased
+# (H) callable at runtime, but cgr saw a bare-name call that resolved to nothing.
+# (H) A call through a local alias must produce a CALLS edge to the aliased target.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+MODULE_SRC = """class Engine:
+ def run(self) -> str:
+ do = self._start
+ return do()
+
+ def _start(self) -> str:
+ return helper()
+
+
+def helper() -> str:
+ return "x"
+
+
+def top() -> str:
+ fn = helper
+ return fn()
+"""
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "m.py").write_text(MODULE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestLocalAliasCalls:
+ def test_alias_to_self_method_is_a_call(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.Engine.run", "proj.m.Engine._start") in calls, calls
+
+ def test_alias_to_module_function_is_a_call(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.top", "proj.m.helper") in calls, calls
+
+ def test_direct_call_unaffected(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.Engine._start", "proj.m.helper") in calls, calls
diff --git a/codebase_rag/tests/test_local_alias_chain_resolution.py b/codebase_rag/tests/test_local_alias_chain_resolution.py
new file mode 100644
index 000000000..a2c964507
--- /dev/null
+++ b/codebase_rag/tests/test_local_alias_chain_resolution.py
@@ -0,0 +1,96 @@
+# (H) L3 finding from the evals/ harness: CallProcessor._ingest_function_calls does
+# (H) `registry = resolver.function_registry` (resolver = self._resolver) then
+# (H) `qn in registry`, dispatching to FunctionRegistryTrie.__contains__. Resolving it
+# (H) needs local-variable aliasing (local = self.attr) plus cross-class attribute-chain
+# (H) typing (local2 = local.attr) so the operand's concrete type is known.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+FILES = {
+ "pkg/__init__.py": "",
+ "pkg/registry.py": (
+ "class Registry:\n def __contains__(self, key):\n return True\n"
+ ),
+ "pkg/resolver.py": (
+ "from .registry import Registry\n\n\n"
+ "class Resolver:\n"
+ " def __init__(self) -> None:\n"
+ " self.registry = Registry()\n"
+ ),
+ "pkg/proc.py": (
+ "from .resolver import Resolver\n\n\n"
+ "class Proc:\n"
+ " def __init__(self) -> None:\n"
+ " self._resolver = Resolver()\n\n"
+ " def run(self, qn):\n"
+ " resolver = self._resolver\n"
+ " registry = resolver.registry\n"
+ " return qn in registry\n"
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestLocalAliasChainResolution:
+ def test_local_alias_attribute_chain_dispatches_to_dunder(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.proc.Proc.run",
+ "proj.pkg.registry.Registry.__contains__",
+ ) in calls, calls
diff --git a/codebase_rag/tests/test_lua_containment_oracle.py b/codebase_rag/tests/test_lua_containment_oracle.py
new file mode 100644
index 000000000..1d517b8ba
--- /dev/null
+++ b/codebase_rag/tests/test_lua_containment_oracle.py
@@ -0,0 +1,56 @@
+# (H) Covers Lua containment-edge validation. Lua has no classes/methods, so the
+# (H) only containment edge is DEFINES: the file module DEFINES top-level
+# (H) functions, and a function DEFINES the functions nested in its body. Graded
+# (H) against the independent luaparse oracle, joined on (kind, file, line).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_lua_graph
+from evals.oracles import lua_oracle_available, run_lua_oracle
+from evals.score import score_edge_types
+
+LUA_SRC = """\
+local function freeFn(a)
+ return a + 1
+end
+
+function globalFn()
+ local function nested()
+ return 1
+ end
+ return nested
+end
+
+local cb = function(x) return x end
+"""
+
+
+def _require_lua() -> None:
+ if not lua_oracle_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.LUA not in load_parsers()[0]:
+ pytest.skip("lua parser not available")
+
+
+def test_cgr_matches_luaparse_oracle_on_containment_edges(tmp_path: Path) -> None:
+ _require_lua()
+ project = tmp_path / "lua_edge"
+ project.mkdir()
+ (project / "lib.lua").write_text(LUA_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_lua_graph(project, project.name)
+ oracle = run_lua_oracle(project)
+
+ result = score_edge_types(cgr, oracle, ec.SCORED_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ # (H) Lua only has DEFINES (no methods, so no DEFINES_METHOD row at all).
+ row = by_label.get(cs.RelationshipType.DEFINES.value)
+ assert row is not None, (by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (row, result.diff)
+ assert cs.RelationshipType.DEFINES_METHOD.value not in by_label, by_label
diff --git a/codebase_rag/tests/test_lua_modern_features.py b/codebase_rag/tests/test_lua_modern_features.py
index 0cf6003a4..a9e84265f 100644
--- a/codebase_rag/tests/test_lua_modern_features.py
+++ b/codebase_rag/tests/test_lua_modern_features.py
@@ -621,9 +621,23 @@ def test_lua_54_enhanced_stdlib(temp_repo: Path, mock_ingestor: MagicMock) -> No
assert expected_fn in fn_qns, f"Missing function: {expected_fn}"
calls_rels = get_relationships(mock_ingestor, "CALLS")
-
- assert len(calls_rels) >= 10, (
- f"Expected at least 10 CALLS, got {len(calls_rels)}"
+ call_edges = {(c.args[0][2], c.args[2][2]) for c in calls_rels}
+
+ # (H) stdlib calls (math.*, string.*, table.*, io.*, os.*) are not
+ # (H) first-party, so the only CALLS edges are between StdLib methods:
+ # (H) run_all_tests fans out to the six test_* methods, and the
+ # (H) top-level `StdLib.run_all_tests()` in main.lua is attributed to
+ # (H) the main module (not duplicated onto every nested call site).
+ run_all = f"{stdlib_qn}.StdLib.run_all_tests"
+ main_qn = f"{project.name}.main"
+ for method in expected_functions:
+ if method == run_all:
+ continue
+ assert (run_all, method) in call_edges, (
+ f"Missing CALLS edge {run_all} -> {method}"
+ )
+ assert (main_qn, run_all) in call_edges, (
+ f"Missing module-level CALLS edge {main_qn} -> {run_all}"
)
print("✅ Lua 5.4 enhanced standard library test PASSED")
diff --git a/codebase_rag/tests/test_lua_span_oracle.py b/codebase_rag/tests/test_lua_span_oracle.py
new file mode 100644
index 000000000..9f70f4641
--- /dev/null
+++ b/codebase_rag/tests/test_lua_span_oracle.py
@@ -0,0 +1,58 @@
+# (H) Covers Lua node SPAN (end_line) validation: cgr's end_line for each Function
+# (H) is graded against the luaparse oracle (which emits node.loc.end.line), joined
+# (H) on (kind, file, start). Exercises a global function, a nested function, and a
+# (H) multi-line anonymous function expression so spans are not single line.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_lua_graph
+from evals.oracles import lua_oracle_available, run_lua_oracle
+from evals.score import score_span
+
+LUA_SRC = """\
+function outer(a, b)
+ local function inner(x)
+ return x + 1
+ end
+ return inner(a) + b
+end
+
+local handler = function(v)
+ return v * 2
+end
+
+return outer(handler(1), 2)
+"""
+
+
+def _require_lua() -> None:
+ if not lua_oracle_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.LUA not in load_parsers()[0]:
+ pytest.skip("lua parser not available")
+
+
+def test_cgr_matches_luaparse_oracle_on_node_spans(tmp_path: Path) -> None:
+ _require_lua()
+ project = tmp_path / "lua_span_test"
+ project.mkdir()
+ (project / "lib.lua").write_text(LUA_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_lua_graph(project, project.name)
+ oracle = run_lua_oracle(project)
+
+ result = score_span(cgr, oracle, ec.LUA_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ aggregate = by_label.get(ec.AGGREGATE_LABEL)
+ assert aggregate is not None, (by_label, result.diff)
+ assert aggregate["precision"] == 1.0 and aggregate["recall"] == 1.0, (
+ aggregate,
+ result.diff,
+ )
+ assert aggregate["tp"] >= 3, aggregate
diff --git a/codebase_rag/tests/test_lua_structure_oracle.py b/codebase_rag/tests/test_lua_structure_oracle.py
new file mode 100644
index 000000000..c30b49f9e
--- /dev/null
+++ b/codebase_rag/tests/test_lua_structure_oracle.py
@@ -0,0 +1,54 @@
+# (H) Covers the Lua structure oracle harness (evals/oracles/lua_oracle +
+# (H) evals/lua_l1.py): the luaparse oracle is authoritative ground truth, and
+# (H) cgr's captured Lua nodes are graded against it on (kind, file, start_line).
+# (H) Lua has no classes, so every function is a Function.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_lua_nodes
+from evals.oracles import lua_oracle_available, run_lua_oracle
+from evals.score import score_node_kinds
+from evals.types_defs import GraphData
+
+LUA_SRC = """\
+local M = {}
+function freeFn(a) return a + 1 end
+local function localFn(b) return b end
+function M.tableFn(c) return c end
+function M:methodFn(d) return d end
+local arrow = function(e) return e end
+return M
+"""
+
+
+def _require_lua() -> None:
+ if not lua_oracle_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.LUA not in load_parsers()[0]:
+ pytest.skip("lua parser not available")
+
+
+def test_cgr_matches_luaparse_oracle_on_lua_structure(tmp_path: Path) -> None:
+ _require_lua()
+ project = tmp_path / "lua_oracle_test"
+ project.mkdir()
+ (project / "m.lua").write_text(LUA_SRC, encoding="utf-8")
+
+ cgr = GraphData(
+ nodes=extract_cgr_lua_nodes(project, project.name),
+ edges=set(),
+ name_edges=set(),
+ )
+ oracle = run_lua_oracle(project)
+
+ result = score_node_kinds(cgr, oracle, ec.LUA_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ row = by_label.get(cs.NodeLabel.FUNCTION.value)
+ assert row is not None, by_label
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, row
diff --git a/codebase_rag/tests/test_mcp_query_and_index.py b/codebase_rag/tests/test_mcp_query_and_index.py
index ce9a5ffcd..89cbdc267 100644
--- a/codebase_rag/tests/test_mcp_query_and_index.py
+++ b/codebase_rag/tests/test_mcp_query_and_index.py
@@ -364,6 +364,77 @@ async def test_sequential_index_only_clears_own_project_data(
assert mock_ingestor.delete_project.call_count == 2
+class TestIndexRepositoryConstraintsAndFlush:
+ """Regression tests for issue #2: MCP indexing produced an incomplete graph.
+
+ The MCP path diverged from the CLI path: it never called
+ ``ensure_constraints()`` and never defensively flushed the long-lived
+ ingestor before/after ``GraphUpdater.run()``, so stale buffered state could
+ leak across calls and missing constraints/indexes corrupted node creation.
+
+ NOTE: A full assertion that ``Class`` and ``Method`` nodes are persisted
+ requires a live Memgraph backend (the in-repo ``_MockIngestor`` does not
+ persist a real graph, and ``GraphUpdater`` emits those node batches
+ regardless of the orchestration bug). These tests instead pin the
+ orchestration that the CLI path performs and the MCP path was missing.
+ """
+
+ @staticmethod
+ def _ordered_calls(manager: MagicMock) -> list[str]:
+ tracked = {
+ "ingestor.ensure_constraints",
+ "ingestor.flush_all",
+ "updater.run",
+ }
+ return [name for name, _, _ in manager.mock_calls if name in tracked]
+
+ async def test_index_ensures_constraints_and_flushes_around_run(
+ self, temp_project_root: Path
+ ) -> None:
+ manager = MagicMock()
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=manager.ingestor,
+ cypher_gen=MagicMock(),
+ )
+
+ with patch("codebase_rag.mcp.tools.GraphUpdater") as mock_updater_class:
+ mock_updater_class.return_value = manager.updater
+ manager.updater.run.return_value = None
+
+ await registry.index_repository()
+
+ assert self._ordered_calls(manager) == [
+ "ingestor.ensure_constraints",
+ "ingestor.flush_all",
+ "updater.run",
+ "ingestor.flush_all",
+ ]
+
+ async def test_update_ensures_constraints_and_flushes_around_run(
+ self, temp_project_root: Path
+ ) -> None:
+ manager = MagicMock()
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=manager.ingestor,
+ cypher_gen=MagicMock(),
+ )
+
+ with patch("codebase_rag.mcp.tools.GraphUpdater") as mock_updater_class:
+ mock_updater_class.return_value = manager.updater
+ manager.updater.run.return_value = None
+
+ await registry.update_repository()
+
+ assert self._ordered_calls(manager) == [
+ "ingestor.ensure_constraints",
+ "ingestor.flush_all",
+ "updater.run",
+ "ingestor.flush_all",
+ ]
+
+
class TestQueryAndIndexIntegration:
"""Test integration between querying and indexing."""
diff --git a/codebase_rag/tests/test_mcp_server.py b/codebase_rag/tests/test_mcp_server.py
index 6d621e76d..c84901bf6 100644
--- a/codebase_rag/tests/test_mcp_server.py
+++ b/codebase_rag/tests/test_mcp_server.py
@@ -1,10 +1,13 @@
+import contextlib
import os
+from collections.abc import AsyncIterator
from pathlib import Path
from typing import Any
-from unittest.mock import patch
+from unittest.mock import AsyncMock, MagicMock, patch
import pytest
+from codebase_rag.mcp import server as srv
from codebase_rag.mcp.server import get_project_root
@@ -173,3 +176,51 @@ def test_works_with_actual_cwd(self) -> None:
assert result == actual_cwd.resolve()
assert result.exists()
assert result.is_dir()
+
+
+class TestServiceLifecycle:
+ """Tests that the MCP server lifecycle releases the Qdrant client."""
+
+ def test_service_lifecycle_closes_qdrant_on_exit(self) -> None:
+ mock_ingestor = MagicMock()
+
+ with patch.object(srv, "close_qdrant_client") as mock_close:
+ with srv._service_lifecycle(mock_ingestor):
+ mock_ingestor.__enter__.assert_called_once()
+ mock_close.assert_not_called()
+ mock_close.assert_called_once_with()
+ mock_ingestor.__exit__.assert_called_once()
+
+ def test_service_lifecycle_closes_qdrant_on_exception(self) -> None:
+ mock_ingestor = MagicMock()
+
+ with patch.object(srv, "close_qdrant_client") as mock_close:
+ with pytest.raises(RuntimeError):
+ with srv._service_lifecycle(mock_ingestor):
+ raise RuntimeError("boom")
+ mock_close.assert_called_once_with()
+ mock_ingestor.__exit__.assert_called_once()
+
+
+class TestServeStdioShutdown:
+ """Tests that serve_stdio releases the Qdrant lock on shutdown."""
+
+ async def test_serve_stdio_closes_qdrant_client_on_shutdown(self) -> None:
+ mock_ingestor = MagicMock()
+ mock_server = MagicMock()
+ mock_server.run = AsyncMock()
+ mock_server.create_initialization_options = MagicMock(return_value=MagicMock())
+
+ @contextlib.asynccontextmanager
+ async def fake_stdio() -> AsyncIterator[tuple[MagicMock, MagicMock]]:
+ yield (MagicMock(), MagicMock())
+
+ with patch.object(
+ srv, "create_server", return_value=(mock_server, mock_ingestor)
+ ):
+ with patch.object(srv, "stdio_server", fake_stdio):
+ with patch.object(srv, "close_qdrant_client") as mock_close:
+ await srv.serve_stdio()
+
+ mock_close.assert_called_once_with()
+ mock_server.run.assert_awaited_once()
diff --git a/codebase_rag/tests/test_mcp_tools_helpers.py b/codebase_rag/tests/test_mcp_tools_helpers.py
new file mode 100644
index 000000000..7804c9fa0
--- /dev/null
+++ b/codebase_rag/tests/test_mcp_tools_helpers.py
@@ -0,0 +1,98 @@
+from unittest.mock import MagicMock, patch
+
+from codebase_rag import constants as cs
+
+_PATCH_DELETE = "codebase_rag.mcp.tools.delete_project_embeddings"
+
+
+def _make_registry(mock_ingestor: MagicMock) -> MagicMock:
+ from codebase_rag.mcp.tools import MCPToolsRegistry
+
+ registry = MagicMock(spec=MCPToolsRegistry)
+ registry.ingestor = mock_ingestor
+ registry._get_project_node_ids = MCPToolsRegistry._get_project_node_ids.__get__(
+ registry
+ )
+ registry._cleanup_project_embeddings = (
+ MCPToolsRegistry._cleanup_project_embeddings.__get__(registry)
+ )
+ return registry
+
+
+class TestGetProjectNodeIds:
+ def test_returns_integer_ids(self) -> None:
+ mock_ingestor = MagicMock()
+ mock_ingestor.fetch_all.return_value = [
+ {cs.KEY_NODE_ID: 1},
+ {cs.KEY_NODE_ID: 2},
+ {cs.KEY_NODE_ID: 3},
+ ]
+ registry = _make_registry(mock_ingestor)
+
+ result = registry._get_project_node_ids("myproject")
+
+ assert result == [1, 2, 3]
+ mock_ingestor.fetch_all.assert_called_once_with(
+ cs.CYPHER_QUERY_PROJECT_NODE_IDS,
+ {cs.KEY_PROJECT_NAME: "myproject"},
+ )
+
+ def test_filters_non_integer_ids(self) -> None:
+ mock_ingestor = MagicMock()
+ mock_ingestor.fetch_all.return_value = [
+ {cs.KEY_NODE_ID: 1},
+ {cs.KEY_NODE_ID: "not_an_int"},
+ {cs.KEY_NODE_ID: None},
+ {cs.KEY_NODE_ID: 4},
+ ]
+ registry = _make_registry(mock_ingestor)
+
+ result = registry._get_project_node_ids("proj")
+
+ assert result == [1, 4]
+
+ def test_returns_empty_when_no_rows(self) -> None:
+ mock_ingestor = MagicMock()
+ mock_ingestor.fetch_all.return_value = []
+ registry = _make_registry(mock_ingestor)
+
+ result = registry._get_project_node_ids("empty")
+
+ assert result == []
+
+ def test_skips_rows_missing_key(self) -> None:
+ mock_ingestor = MagicMock()
+ mock_ingestor.fetch_all.return_value = [
+ {"other_key": 99},
+ {cs.KEY_NODE_ID: 5},
+ ]
+ registry = _make_registry(mock_ingestor)
+
+ result = registry._get_project_node_ids("proj")
+
+ assert result == [5]
+
+
+class TestCleanupProjectEmbeddings:
+ def test_calls_delete_with_node_ids(self) -> None:
+ mock_ingestor = MagicMock()
+ mock_ingestor.fetch_all.return_value = [
+ {cs.KEY_NODE_ID: 10},
+ {cs.KEY_NODE_ID: 20},
+ ]
+ registry = _make_registry(mock_ingestor)
+
+ with patch(_PATCH_DELETE) as mock_delete:
+ registry._cleanup_project_embeddings("myproject")
+
+ mock_delete.assert_called_once_with("myproject", [10, 20])
+
+ def test_calls_delete_with_empty_list_when_no_nodes(self) -> None:
+ mock_ingestor = MagicMock()
+ mock_ingestor.fetch_all.return_value = []
+ registry = _make_registry(mock_ingestor)
+
+ with patch(_PATCH_DELETE) as mock_delete:
+ registry._cleanup_project_embeddings("empty_proj")
+
+ mock_delete.assert_called_once_with("empty_proj", [])
diff --git a/codebase_rag/tests/test_mcp_update_and_search.py b/codebase_rag/tests/test_mcp_update_and_search.py
new file mode 100644
index 000000000..b01128931
--- /dev/null
+++ b/codebase_rag/tests/test_mcp_update_and_search.py
@@ -0,0 +1,496 @@
+from pathlib import Path
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.mcp.client import query_mcp_server
+from codebase_rag.mcp.tools import MCPToolsRegistry
+
+pytestmark = [pytest.mark.anyio]
+
+
+@pytest.fixture(params=["asyncio"])
+def anyio_backend(request: pytest.FixtureRequest) -> str:
+ return str(request.param)
+
+
+@pytest.fixture
+def temp_project_root(tmp_path: Path) -> Path:
+ sample_file = tmp_path / "app.py"
+ sample_file.write_text("def main(): pass\n", encoding="utf-8")
+ return tmp_path
+
+
+@pytest.fixture
+def mcp_registry(temp_project_root: Path) -> MCPToolsRegistry:
+ mock_ingestor = MagicMock()
+ mock_cypher_gen = MagicMock()
+
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=mock_ingestor,
+ cypher_gen=mock_cypher_gen,
+ )
+ return registry
+
+
+class TestUpdateRepository:
+ async def test_update_repository_success(
+ self, mcp_registry: MCPToolsRegistry
+ ) -> None:
+ with patch("codebase_rag.mcp.tools.GraphUpdater") as mock_updater_cls:
+ mock_updater = MagicMock()
+ mock_updater_cls.return_value = mock_updater
+
+ result = await mcp_registry.update_repository()
+
+ mock_updater_cls.assert_called_once()
+ mock_updater.run.assert_called_once()
+ assert mcp_registry.project_root in result
+
+ async def test_update_repository_error(
+ self, mcp_registry: MCPToolsRegistry
+ ) -> None:
+ with patch("codebase_rag.mcp.tools.GraphUpdater") as mock_updater_cls:
+ mock_updater_cls.side_effect = RuntimeError("parse error")
+
+ result = await mcp_registry.update_repository()
+
+ assert "Error" in result
+
+ async def test_update_repository_registered(
+ self, mcp_registry: MCPToolsRegistry
+ ) -> None:
+ assert cs.MCPToolName.UPDATE_REPOSITORY in mcp_registry._tools
+
+ async def test_update_repository_no_wipe(
+ self, mcp_registry: MCPToolsRegistry
+ ) -> None:
+ with patch("codebase_rag.mcp.tools.GraphUpdater") as mock_updater_cls:
+ mock_updater = MagicMock()
+ mock_updater_cls.return_value = mock_updater
+
+ await mcp_registry.update_repository()
+
+ mcp_registry.ingestor.delete_project.assert_not_called()
+ mcp_registry.ingestor.clean_database.assert_not_called()
+
+
+class TestSemanticSearchRegistration:
+ def test_semantic_search_not_registered_without_deps(
+ self, temp_project_root: Path
+ ) -> None:
+ mock_ingestor = MagicMock()
+ mock_cypher_gen = MagicMock()
+
+ with patch(
+ "codebase_rag.mcp.tools.has_semantic_dependencies",
+ return_value=False,
+ ):
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=mock_ingestor,
+ cypher_gen=mock_cypher_gen,
+ )
+
+ assert cs.MCPToolName.SEMANTIC_SEARCH not in registry._tools
+ assert registry._semantic_search_available is False
+
+ def test_semantic_search_registered_with_deps(
+ self, temp_project_root: Path
+ ) -> None:
+ mock_ingestor = MagicMock()
+ mock_cypher_gen = MagicMock()
+
+ with (
+ patch(
+ "codebase_rag.mcp.tools.has_semantic_dependencies",
+ return_value=True,
+ ),
+ patch(
+ "codebase_rag.tools.semantic_search.create_semantic_search_tool"
+ ) as mock_create,
+ ):
+ mock_tool = MagicMock()
+ mock_create.return_value = mock_tool
+
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=mock_ingestor,
+ cypher_gen=mock_cypher_gen,
+ )
+
+ assert cs.MCPToolName.SEMANTIC_SEARCH in registry._tools
+ assert registry._semantic_search_available is True
+
+ async def test_semantic_search_calls_tool(self, temp_project_root: Path) -> None:
+ mock_ingestor = MagicMock()
+ mock_cypher_gen = MagicMock()
+
+ with (
+ patch(
+ "codebase_rag.mcp.tools.has_semantic_dependencies",
+ return_value=True,
+ ),
+ patch(
+ "codebase_rag.tools.semantic_search.create_semantic_search_tool"
+ ) as mock_create,
+ ):
+ mock_tool = MagicMock()
+ mock_tool.function = AsyncMock(return_value="result1, result2")
+ mock_create.return_value = mock_tool
+
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=mock_ingestor,
+ cypher_gen=mock_cypher_gen,
+ )
+
+ result = await registry.semantic_search("find auth functions", top_k=3)
+
+ mock_tool.function.assert_called_once_with(
+ query="find auth functions", top_k=3
+ )
+ assert "result1" in result
+
+
+class TestAskAgent:
+ async def test_ask_agent_registered(self, mcp_registry: MCPToolsRegistry) -> None:
+ assert cs.MCPToolName.ASK_AGENT in mcp_registry._tools
+
+ async def test_ask_agent_success(self, mcp_registry: MCPToolsRegistry) -> None:
+ mock_agent = MagicMock()
+ mock_response = MagicMock()
+ mock_response.output = "The auth module uses JWT tokens."
+ mock_agent.run = AsyncMock(return_value=mock_response)
+ mcp_registry.rag_agent = mock_agent
+
+ result = await mcp_registry.ask_agent("How is auth implemented?")
+
+ assert result["output"] == "The auth module uses JWT tokens."
+ mock_agent.run.assert_called_once_with(
+ "How is auth implemented?", message_history=[]
+ )
+
+ async def test_ask_agent_error(self, mcp_registry: MCPToolsRegistry) -> None:
+ mock_agent = MagicMock()
+ mock_agent.run = AsyncMock(side_effect=RuntimeError("LLM unavailable"))
+ mcp_registry.rag_agent = mock_agent
+
+ result = await mcp_registry.ask_agent("What does main do?")
+
+ assert "error" in result
+
+
+class TestToolDescriptions:
+ def test_update_repository_in_tool_map(self) -> None:
+ from codebase_rag.tools.tool_descriptions import MCP_TOOLS
+
+ assert cs.MCPToolName.UPDATE_REPOSITORY in MCP_TOOLS
+
+ def test_semantic_search_in_tool_map(self) -> None:
+ from codebase_rag.tools.tool_descriptions import MCP_TOOLS
+
+ assert cs.MCPToolName.SEMANTIC_SEARCH in MCP_TOOLS
+
+ def test_ask_agent_in_tool_map(self) -> None:
+ from codebase_rag.tools.tool_descriptions import MCP_TOOLS
+
+ assert cs.MCPToolName.ASK_AGENT in MCP_TOOLS
+
+ def test_index_repository_warns_about_project_clear(self) -> None:
+ from codebase_rag.tools.tool_descriptions import MCP_INDEX_REPOSITORY
+
+ assert "current project" in MCP_INDEX_REPOSITORY
+ assert "entire database" not in MCP_INDEX_REPOSITORY
+
+
+class TestRagAgentProperty:
+ def test_rag_agent_setter_allows_mock(self, mcp_registry: MCPToolsRegistry) -> None:
+ mock_agent = MagicMock()
+ mcp_registry.rag_agent = mock_agent
+ assert mcp_registry.rag_agent is mock_agent
+
+ def test_rag_agent_lazy_init(self, temp_project_root: Path) -> None:
+ mock_ingestor = MagicMock()
+ mock_cypher_gen = MagicMock()
+
+ with patch(
+ "codebase_rag.mcp.tools.has_semantic_dependencies",
+ return_value=False,
+ ):
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=mock_ingestor,
+ cypher_gen=mock_cypher_gen,
+ )
+
+ assert registry._rag_agent is None
+
+ with patch("codebase_rag.mcp.tools.create_rag_orchestrator") as mock_create:
+ mock_agent = MagicMock()
+ mock_create.return_value = (mock_agent, "system prompt")
+
+ agent = registry.rag_agent
+
+ mock_create.assert_called_once()
+ assert agent is mock_agent
+
+ def test_rag_agent_includes_function_source_tool(
+ self, temp_project_root: Path
+ ) -> None:
+ mock_ingestor = MagicMock()
+ mock_cypher_gen = MagicMock()
+
+ with patch(
+ "codebase_rag.mcp.tools.has_semantic_dependencies",
+ return_value=False,
+ ):
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=mock_ingestor,
+ cypher_gen=mock_cypher_gen,
+ )
+
+ with (
+ patch("codebase_rag.mcp.tools.create_rag_orchestrator") as mock_create,
+ patch(
+ "codebase_rag.tools.semantic_search.create_get_function_source_tool"
+ ) as mock_fst,
+ ):
+ mock_tool = MagicMock()
+ mock_fst.return_value = mock_tool
+ mock_create.return_value = (MagicMock(), "system prompt")
+
+ registry.rag_agent
+
+ tools_arg = mock_create.call_args[1]["tools"]
+ assert mock_tool in tools_arg
+
+ def test_rag_agent_includes_semantic_search_when_available(
+ self, temp_project_root: Path
+ ) -> None:
+ mock_ingestor = MagicMock()
+ mock_cypher_gen = MagicMock()
+
+ with (
+ patch(
+ "codebase_rag.mcp.tools.has_semantic_dependencies",
+ return_value=True,
+ ),
+ patch(
+ "codebase_rag.tools.semantic_search.create_semantic_search_tool"
+ ) as mock_ss,
+ ):
+ mock_ss_tool = MagicMock()
+ mock_ss.return_value = mock_ss_tool
+
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=mock_ingestor,
+ cypher_gen=mock_cypher_gen,
+ )
+
+ with (
+ patch("codebase_rag.mcp.tools.create_rag_orchestrator") as mock_create,
+ patch("codebase_rag.tools.semantic_search.create_get_function_source_tool"),
+ ):
+ mock_create.return_value = (MagicMock(), "system prompt")
+ registry.rag_agent
+
+ tools_arg = mock_create.call_args[1]["tools"]
+ assert mock_ss_tool in tools_arg
+
+ def test_rag_agent_caches_after_first_access(self, temp_project_root: Path) -> None:
+ mock_ingestor = MagicMock()
+ mock_cypher_gen = MagicMock()
+
+ with patch(
+ "codebase_rag.mcp.tools.has_semantic_dependencies",
+ return_value=False,
+ ):
+ registry = MCPToolsRegistry(
+ project_root=str(temp_project_root),
+ ingestor=mock_ingestor,
+ cypher_gen=mock_cypher_gen,
+ )
+
+ with (
+ patch("codebase_rag.mcp.tools.create_rag_orchestrator") as mock_create,
+ patch("codebase_rag.tools.semantic_search.create_get_function_source_tool"),
+ ):
+ mock_create.return_value = (MagicMock(), "system prompt")
+
+ agent1 = registry.rag_agent
+ agent2 = registry.rag_agent
+
+ mock_create.assert_called_once()
+ assert agent1 is agent2
+
+
+class TestMainSingleQuery:
+ def test_main_single_query_prints_output(
+ self, tmp_path: Path, capsys: pytest.CaptureFixture[str]
+ ) -> None:
+ from codebase_rag.main import main_single_query
+
+ mock_response = MagicMock()
+ mock_response.output = "The answer is 42."
+
+ with (
+ patch("codebase_rag.main.connect_memgraph") as mock_conn,
+ patch("codebase_rag.main._initialize_services_and_agent") as mock_init,
+ patch("codebase_rag.main.asyncio") as mock_asyncio,
+ patch("codebase_rag.main._setup_common_initialization"),
+ ):
+ mock_agent = MagicMock()
+ mock_init.return_value = (mock_agent, [], "system prompt")
+ mock_asyncio.run.return_value = mock_response
+ mock_conn.return_value.__enter__ = MagicMock(return_value=MagicMock())
+ mock_conn.return_value.__exit__ = MagicMock(return_value=False)
+
+ main_single_query(str(tmp_path), 1000, "What is the answer?")
+
+ captured = capsys.readouterr()
+ assert "The answer is 42." in captured.out
+
+ def test_main_single_query_routes_logs_to_stderr(self, tmp_path: Path) -> None:
+ from codebase_rag.main import main_single_query
+
+ mock_response = MagicMock()
+ mock_response.output = "result"
+
+ with (
+ patch("codebase_rag.main.connect_memgraph") as mock_conn,
+ patch("codebase_rag.main._initialize_services_and_agent") as mock_init,
+ patch("codebase_rag.main.asyncio") as mock_asyncio,
+ patch("codebase_rag.main._setup_common_initialization"),
+ patch("codebase_rag.main.logger") as mock_logger,
+ ):
+ mock_agent = MagicMock()
+ mock_init.return_value = (mock_agent, [], "system prompt")
+ mock_asyncio.run.return_value = mock_response
+ mock_conn.return_value.__enter__ = MagicMock(return_value=MagicMock())
+ mock_conn.return_value.__exit__ = MagicMock(return_value=False)
+
+ main_single_query(str(tmp_path), 1000, "test")
+
+ mock_logger.remove.assert_called_once()
+ mock_logger.add.assert_called_once()
+ add_args = mock_logger.add.call_args
+ import sys
+
+ assert add_args[0][0] is sys.stderr
+
+
+class TestMCPClient:
+ def test_query_mcp_server_is_callable(self) -> None:
+ assert callable(query_mcp_server)
+
+ def test_client_uses_constants(self) -> None:
+ import inspect
+
+ from codebase_rag.mcp import client
+
+ source = inspect.getsource(client)
+ assert "MCPToolName.ASK_AGENT" in source
+ assert "MCPParamName.QUESTION" in source
+
+ def test_query_with_errlog_is_async(self) -> None:
+ import asyncio
+
+ from codebase_rag.mcp.client import _query_with_errlog
+
+ assert asyncio.iscoroutinefunction(_query_with_errlog)
+
+ async def test_query_with_errlog_json_response(self) -> None:
+ import io
+
+ from codebase_rag.mcp.client import _query_with_errlog
+
+ mock_content = MagicMock()
+ mock_content.text = '{"output": "test answer"}'
+ mock_result = MagicMock()
+ mock_result.content = [mock_content]
+
+ mock_session = AsyncMock()
+ mock_session.initialize = AsyncMock()
+ mock_session.call_tool = AsyncMock(return_value=mock_result)
+ mock_session.__aenter__ = AsyncMock(return_value=mock_session)
+ mock_session.__aexit__ = AsyncMock(return_value=False)
+
+ mock_transport = AsyncMock()
+ mock_transport.__aenter__ = AsyncMock(return_value=(MagicMock(), MagicMock()))
+ mock_transport.__aexit__ = AsyncMock(return_value=False)
+
+ with (
+ patch("codebase_rag.mcp.client.stdio_client", return_value=mock_transport),
+ patch("codebase_rag.mcp.client.ClientSession", return_value=mock_session),
+ ):
+ result = await _query_with_errlog("test question", io.StringIO())
+
+ assert result == {"output": "test answer"}
+
+ async def test_query_with_errlog_non_json_response(self) -> None:
+ import io
+
+ from codebase_rag.mcp.client import _query_with_errlog
+
+ mock_content = MagicMock()
+ mock_content.text = "plain text response"
+ mock_result = MagicMock()
+ mock_result.content = [mock_content]
+
+ mock_session = AsyncMock()
+ mock_session.initialize = AsyncMock()
+ mock_session.call_tool = AsyncMock(return_value=mock_result)
+ mock_session.__aenter__ = AsyncMock(return_value=mock_session)
+ mock_session.__aexit__ = AsyncMock(return_value=False)
+
+ mock_transport = AsyncMock()
+ mock_transport.__aenter__ = AsyncMock(return_value=(MagicMock(), MagicMock()))
+ mock_transport.__aexit__ = AsyncMock(return_value=False)
+
+ with (
+ patch("codebase_rag.mcp.client.stdio_client", return_value=mock_transport),
+ patch("codebase_rag.mcp.client.ClientSession", return_value=mock_session),
+ ):
+ result = await _query_with_errlog("test", io.StringIO())
+
+ assert result == {"output": "plain text response"}
+
+ async def test_query_with_errlog_empty_response(self) -> None:
+ import io
+
+ from codebase_rag.mcp.client import _query_with_errlog
+
+ mock_result = MagicMock()
+ mock_result.content = []
+
+ mock_session = AsyncMock()
+ mock_session.initialize = AsyncMock()
+ mock_session.call_tool = AsyncMock(return_value=mock_result)
+ mock_session.__aenter__ = AsyncMock(return_value=mock_session)
+ mock_session.__aexit__ = AsyncMock(return_value=False)
+
+ mock_transport = AsyncMock()
+ mock_transport.__aenter__ = AsyncMock(return_value=(MagicMock(), MagicMock()))
+ mock_transport.__aexit__ = AsyncMock(return_value=False)
+
+ with (
+ patch("codebase_rag.mcp.client.stdio_client", return_value=mock_transport),
+ patch("codebase_rag.mcp.client.ClientSession", return_value=mock_session),
+ ):
+ result = await _query_with_errlog("test", io.StringIO())
+
+ assert result == {"output": "No response from server"}
+
+ def test_query_mcp_server_opens_devnull(self) -> None:
+ with (
+ patch("codebase_rag.mcp.client.asyncio") as mock_asyncio,
+ patch("builtins.open", MagicMock()) as mock_open,
+ ):
+ mock_asyncio.run.return_value = {"output": "result"}
+ query_mcp_server("test")
+ mock_open.assert_called_once()
diff --git a/codebase_rag/tests/test_mcp_write_file.py b/codebase_rag/tests/test_mcp_write_file.py
index 6c214c12a..dd222e9c6 100644
--- a/codebase_rag/tests/test_mcp_write_file.py
+++ b/codebase_rag/tests/test_mcp_write_file.py
@@ -199,6 +199,10 @@ class TestWriteFileErrorHandling:
@pytest.mark.skipif(
os.name == "nt", reason="chmod 0o444 does not prevent file creation on Windows"
)
+ @pytest.mark.skipif(
+ hasattr(os, "getuid") and os.getuid() == 0,
+ reason="root bypasses filesystem permissions",
+ )
async def test_write_to_readonly_directory(
self, mcp_registry: MCPToolsRegistry, temp_project_root: Path
) -> None:
diff --git a/codebase_rag/tests/test_memgraph_batching.py b/codebase_rag/tests/test_memgraph_batching.py
index a3297e819..81c068b66 100644
--- a/codebase_rag/tests/test_memgraph_batching.py
+++ b/codebase_rag/tests/test_memgraph_batching.py
@@ -64,15 +64,20 @@ def test_node_batch_preserves_per_row_properties() -> None:
def test_relationship_batch_flushes_after_threshold_and_respects_node_flush() -> None:
ingestor, cursor_mock = _create_ingestor_with_mocked_connection()
+ col = MagicMock()
+ col.name = "created"
+ cursor_mock.description = [col]
+ cursor_mock.fetchall.return_value = [(1,), (1,)]
+
with patch.object(
- ingestor, "flush_nodes", wraps=ingestor.flush_nodes
+ MemgraphIngestor, "flush_nodes", wraps=ingestor.flush_nodes
) as flush_nodes_spy:
ingestor.ensure_relationship_batch(
("Module", "qualified_name", "proj.module1"),
"CONTAINS_FILE",
("File", "path", "file1"),
)
- assert len(ingestor.relationship_buffer) == 1
+ assert ingestor._rel_count == 1
cursor_mock.execute.assert_not_called()
ingestor.ensure_relationship_batch(
@@ -83,7 +88,7 @@ def test_relationship_batch_flushes_after_threshold_and_respects_node_flush() ->
assert flush_nodes_spy.call_count == 1
- assert len(ingestor.relationship_buffer) == 0
+ assert ingestor._rel_count == 0
cursor_mock.execute.assert_called_once()
executed_query = cursor_mock.execute.call_args[0][0]
assert "UNWIND $batch" in executed_query
diff --git a/codebase_rag/tests/test_memory_limit.py b/codebase_rag/tests/test_memory_limit.py
new file mode 100644
index 000000000..8fed07bad
--- /dev/null
+++ b/codebase_rag/tests/test_memory_limit.py
@@ -0,0 +1,43 @@
+from __future__ import annotations
+
+import pytest
+
+from codebase_rag.services.graph_service import _apply_memory_limit
+
+
+class TestApplyMemoryLimit:
+ def test_appends_hint_to_simple_query(self) -> None:
+ result = _apply_memory_limit("MATCH (n) RETURN n;", 4096)
+ assert result == "MATCH (n) RETURN n QUERY MEMORY LIMIT 4096 MB;"
+
+ def test_appends_hint_when_no_trailing_semicolon(self) -> None:
+ result = _apply_memory_limit("MATCH (n) RETURN n", 256)
+ assert result == "MATCH (n) RETURN n QUERY MEMORY LIMIT 256 MB;"
+
+ def test_preserves_existing_hint(self) -> None:
+ query = "MATCH (n) RETURN n QUERY MEMORY LIMIT 1024 MB;"
+ assert _apply_memory_limit(query, 4096) == query
+
+ def test_preserves_existing_hint_case_insensitive(self) -> None:
+ query = "MATCH (n) RETURN n query memory limit 1024 mb;"
+ assert _apply_memory_limit(query, 4096) == query
+
+ def test_handles_trailing_whitespace(self) -> None:
+ result = _apply_memory_limit("MATCH (n) RETURN n;\n ", 4096)
+ assert result == "MATCH (n) RETURN n QUERY MEMORY LIMIT 4096 MB;"
+
+ def test_handles_whitespace_before_semicolon(self) -> None:
+ result = _apply_memory_limit("MATCH (n) RETURN n ;", 4096)
+ assert result == "MATCH (n) RETURN n QUERY MEMORY LIMIT 4096 MB;"
+
+ def test_handles_multiline_query(self) -> None:
+ query = "MATCH (a)-[:CALLS*1..6]->(b)\nRETURN a, b;"
+ result = _apply_memory_limit(query, 2048)
+ assert result == (
+ "MATCH (a)-[:CALLS*1..6]->(b)\nRETURN a, b QUERY MEMORY LIMIT 2048 MB;"
+ )
+
+ @pytest.mark.parametrize("mb", [128, 256, 1024, 4096, 16384])
+ def test_uses_configured_megabytes(self, mb: int) -> None:
+ result = _apply_memory_limit("MATCH (n) RETURN n;", mb)
+ assert f"QUERY MEMORY LIMIT {mb} MB" in result
diff --git a/codebase_rag/tests/test_method_calls_caller_attribution.py b/codebase_rag/tests/test_method_calls_caller_attribution.py
new file mode 100644
index 000000000..6c4cd2a01
--- /dev/null
+++ b/codebase_rag/tests/test_method_calls_caller_attribution.py
@@ -0,0 +1,679 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import TYPE_CHECKING
+from unittest.mock import MagicMock
+
+from codebase_rag import constants as cs
+from codebase_rag.tests.conftest import get_relationships, run_updater
+
+if TYPE_CHECKING:
+ pass
+
+
+def _get_method_caller_calls(mock_ingestor: MagicMock) -> list:
+ return [
+ c
+ for c in get_relationships(mock_ingestor, cs.RelationshipType.CALLS)
+ if c.args[0][0] == cs.NodeLabel.METHOD
+ ]
+
+
+def _get_function_caller_calls(mock_ingestor: MagicMock) -> list:
+ return [
+ c
+ for c in get_relationships(mock_ingestor, cs.RelationshipType.CALLS)
+ if c.args[0][0] == cs.NodeLabel.FUNCTION
+ ]
+
+
+def _get_module_caller_calls(mock_ingestor: MagicMock) -> list:
+ return [
+ c
+ for c in get_relationships(mock_ingestor, cs.RelationshipType.CALLS)
+ if c.args[0][0] == cs.NodeLabel.MODULE
+ ]
+
+
+def _caller_qn(call: MagicMock) -> str:
+ return call.args[0][2]
+
+
+def _callee_qn(call: MagicMock) -> str:
+ return call.args[2][2]
+
+
+class TestCppMethodCallerAttribution:
+ def test_simple_class_method_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "player.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Player {
+public:
+ void handleArtifact() {}
+
+ void handleArtifactWatcherCb() {
+ handleArtifact();
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ callees = [_callee_qn(c) for c in method_calls]
+
+ watcher_callers = [qn for qn in callers if "handleArtifactWatcherCb" in qn]
+ assert len(watcher_callers) >= 1
+
+ artifact_callees = [qn for qn in callees if "handleArtifact" in qn]
+ assert len(artifact_callees) >= 1
+
+ def test_struct_method_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "sensor.cpp").write_text(
+ encoding="utf-8",
+ data="""
+struct Sensor {
+ int readRaw() { return 42; }
+
+ int readCalibrated() {
+ return readRaw() * 2;
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ callees = [_callee_qn(c) for c in method_calls]
+
+ assert any("readCalibrated" in qn for qn in callers)
+ assert any("readRaw" in qn for qn in callees)
+
+ def test_multiple_methods_calling_each_other(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "calc.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Calculator {
+public:
+ int add(int a, int b) { return a + b; }
+ int multiply(int a, int b) { return a * b; }
+
+ int compute(int x) {
+ int sum = add(x, 1);
+ return multiply(sum, 2);
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ compute_calls = [c for c in method_calls if "compute" in _caller_qn(c)]
+ compute_callees = {_callee_qn(c) for c in compute_calls}
+
+ assert any("add" in qn for qn in compute_callees)
+ assert any("multiply" in qn for qn in compute_callees)
+
+ def test_constructor_body_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "init.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Engine {
+public:
+ void initialize() {}
+
+ Engine() {
+ initialize();
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callees = [_callee_qn(c) for c in method_calls]
+ assert any("initialize" in qn for qn in callees)
+
+ def test_method_calling_free_function_has_method_caller(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "mixed.cpp").write_text(
+ encoding="utf-8",
+ data="""
+void freeHelper() {}
+
+class Service {
+public:
+ void process() {
+ freeHelper();
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ process_calls = [c for c in method_calls if "process" in _caller_qn(c)]
+ assert len(process_calls) >= 1
+
+ def test_multiple_classes_in_one_file(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "multi.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Alpha {
+public:
+ void step1() {}
+ void run() { step1(); }
+};
+
+class Beta {
+public:
+ void step2() {}
+ void execute() { step2(); }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = {_caller_qn(c) for c in method_calls}
+ callees = {_callee_qn(c) for c in method_calls}
+
+ assert any("run" in qn for qn in callers)
+ assert any("execute" in qn for qn in callers)
+ assert any("step1" in qn for qn in callees)
+ assert any("step2" in qn for qn in callees)
+
+ def test_method_with_parameters(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "params.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Parser {
+public:
+ int parse(const char* input, int length) { return 0; }
+
+ int parseFile(const char* path) {
+ return parse(path, 100);
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("parseFile" in qn for qn in callers)
+
+ def test_virtual_method_calls(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "virtual.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Base {
+public:
+ virtual void onEvent() {}
+
+ void dispatch() {
+ onEvent();
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ dispatch_calls = [c for c in method_calls if "dispatch" in _caller_qn(c)]
+ assert len(dispatch_calls) >= 1
+ assert any("onEvent" in _callee_qn(c) for c in dispatch_calls)
+
+ def test_method_calling_another_via_this_pointer(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "this_ptr.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Widget {
+public:
+ void repaint() {}
+
+ void resize(int w, int h) {
+ this->repaint();
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("resize" in qn for qn in callers)
+
+ def test_deeply_nested_call_chain(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "chain.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Pipeline {
+public:
+ int validate() { return 1; }
+ int transform(int x) { return x * 2; }
+ int output(int x) { return x; }
+
+ int run() {
+ int v = validate();
+ int t = transform(v);
+ return output(t);
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ run_calls = [c for c in method_calls if "run" in _caller_qn(c)]
+ run_callees = {_callee_qn(c) for c in run_calls}
+
+ assert any("validate" in qn for qn in run_callees)
+ assert any("transform" in qn for qn in run_callees)
+ assert any("output" in qn for qn in run_callees)
+
+ def test_static_method_calls(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "static.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Factory {
+public:
+ static int create() { return 0; }
+
+ static int build() {
+ return create();
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("build" in qn for qn in callers)
+
+ def test_const_method_calls(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "const.cpp").write_text(
+ encoding="utf-8",
+ data="""
+class Container {
+public:
+ int size() const { return 10; }
+
+ bool empty() const {
+ return size() == 0;
+ }
+};
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.CPP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("empty" in qn for qn in callers)
+
+
+class TestPythonMethodCallerAttribution:
+ def test_method_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "service.py").write_text(
+ encoding="utf-8",
+ data="""
+class Service:
+ def validate(self):
+ pass
+
+ def process(self):
+ self.validate()
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.PYTHON)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("process" in qn for qn in callers)
+
+ def test_multiple_methods_calling_each_other(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "pipeline.py").write_text(
+ encoding="utf-8",
+ data="""
+class Pipeline:
+ def step1(self):
+ pass
+
+ def step2(self):
+ self.step1()
+
+ def run(self):
+ self.step2()
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.PYTHON)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = {_caller_qn(c) for c in method_calls}
+ assert any("step2" in qn for qn in callers)
+ assert any("run" in qn for qn in callers)
+
+ def test_dunder_init_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "init.py").write_text(
+ encoding="utf-8",
+ data="""
+class Config:
+ def _load(self):
+ pass
+
+ def __init__(self):
+ self._load()
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.PYTHON)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("__init__" in qn for qn in callers)
+
+
+class TestJavaScriptMethodCallerAttribution:
+ def test_class_method_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "service.js").write_text(
+ encoding="utf-8",
+ data="""
+class Service {
+ validate() {
+ return true;
+ }
+
+ process() {
+ return this.validate();
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.JS)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("process" in qn for qn in callers)
+
+ def test_constructor_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "widget.js").write_text(
+ encoding="utf-8",
+ data="""
+class Widget {
+ setup() {}
+
+ constructor() {
+ this.setup();
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.JS)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callees = [_callee_qn(c) for c in method_calls]
+ assert any("setup" in qn for qn in callees)
+
+
+class TestTypeScriptMethodCallerAttribution:
+ def test_class_method_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "handler.ts").write_text(
+ encoding="utf-8",
+ data="""
+class Handler {
+ private validate(): boolean {
+ return true;
+ }
+
+ public handle(): void {
+ this.validate();
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.TS)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("handle" in qn for qn in callers)
+
+ def test_multiple_methods_with_types(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "repo.ts").write_text(
+ encoding="utf-8",
+ data="""
+class Repository {
+ find(id: number): string { return ""; }
+ validate(data: string): boolean { return true; }
+
+ save(id: number): boolean {
+ const item = this.find(id);
+ return this.validate(item);
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.TS)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ save_calls = [c for c in method_calls if "save" in _caller_qn(c)]
+ save_callees = {_callee_qn(c) for c in save_calls}
+ assert any("find" in qn for qn in save_callees)
+ assert any("validate" in qn for qn in save_callees)
+
+
+class TestJavaMethodCallerAttribution:
+ def test_method_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "Service.java").write_text(
+ encoding="utf-8",
+ data="""
+public class Service {
+ private boolean validate() {
+ return true;
+ }
+
+ public void process() {
+ validate();
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.JAVA)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("process" in qn for qn in callers)
+
+ def test_constructor_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "Config.java").write_text(
+ encoding="utf-8",
+ data="""
+public class Config {
+ private void loadDefaults() {}
+
+ public Config() {
+ loadDefaults();
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.JAVA)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callees = [_callee_qn(c) for c in method_calls]
+ assert any("loadDefaults" in qn for qn in callees)
+
+ def test_multiple_methods_calling_each_other(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "Calculator.java").write_text(
+ encoding="utf-8",
+ data="""
+public class Calculator {
+ public int add(int a, int b) { return a + b; }
+ public int multiply(int a, int b) { return a * b; }
+
+ public int compute(int x) {
+ int sum = add(x, 1);
+ return multiply(sum, 2);
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.JAVA)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ compute_calls = [c for c in method_calls if "compute" in _caller_qn(c)]
+ compute_callees = {_callee_qn(c) for c in compute_calls}
+ assert any("add" in qn for qn in compute_callees)
+ assert any("multiply" in qn for qn in compute_callees)
+
+
+class TestRustMethodCallerAttribution:
+ def test_impl_method_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "lib.rs").write_text(
+ encoding="utf-8",
+ data="""
+struct Player {
+ health: i32,
+}
+
+impl Player {
+ fn heal(&mut self) {
+ self.health += 10;
+ }
+
+ fn take_damage(&mut self, amount: i32) {
+ self.health -= amount;
+ self.heal();
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.RUST)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("take_damage" in qn for qn in callers)
+
+ def test_multiple_impl_methods(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "lib.rs").write_text(
+ encoding="utf-8",
+ data="""
+struct Pipeline;
+
+impl Pipeline {
+ fn validate(&self) -> bool { true }
+ fn transform(&self, x: i32) -> i32 { x * 2 }
+
+ fn run(&self, input: i32) -> i32 {
+ if self.validate() {
+ self.transform(input)
+ } else {
+ 0
+ }
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.RUST)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ run_calls = [c for c in method_calls if "run" in _caller_qn(c)]
+ assert len(run_calls) >= 1
+
+
+class TestPhpMethodCallerAttribution:
+ def test_method_calls_method(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "service.php").write_text(
+ encoding="utf-8",
+ data="""validate();
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.PHP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = [_caller_qn(c) for c in method_calls]
+ assert any("process" in qn for qn in callers)
+
+ def test_multiple_methods_calling_each_other(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "pipeline.php").write_text(
+ encoding="utf-8",
+ data="""step1();
+ }
+
+ public function run() {
+ $this->step2();
+ }
+}
+""",
+ )
+ run_updater(temp_repo, mock_ingestor, cs.SupportedLanguage.PHP)
+
+ method_calls = _get_method_caller_calls(mock_ingestor)
+ callers = {_caller_qn(c) for c in method_calls}
+ assert any("step2" in qn for qn in callers)
+ assert any("run" in qn for qn in callers)
diff --git a/codebase_rag/tests/test_model_switching.py b/codebase_rag/tests/test_model_switching.py
index 52fb1e632..14217f0d1 100644
--- a/codebase_rag/tests/test_model_switching.py
+++ b/codebase_rag/tests/test_model_switching.py
@@ -235,6 +235,201 @@ async def test_model_override_none_by_default(self) -> None:
assert kwargs.get("model") is None
+class TestAgentLoopUserPromptOnResume:
+ @staticmethod
+ def _make_response(output: object) -> MagicMock:
+ response = MagicMock()
+ response.output = output
+ response.new_messages.return_value = []
+ return response
+
+ @staticmethod
+ def _patches():
+ from pydantic_ai import DeferredToolResults
+
+ return (
+ patch("codebase_rag.main.app_context"),
+ patch("codebase_rag.main.log_session_event"),
+ patch(
+ "codebase_rag.main._process_tool_approvals",
+ new=AsyncMock(return_value=DeferredToolResults()),
+ ),
+ patch("codebase_rag.main._refresh_context_tokens", new=AsyncMock()),
+ patch("codebase_rag.main._thinking_with_status_bar"),
+ )
+
+ @pytest.mark.asyncio
+ async def test_user_prompt_not_resent_after_deferred_tool_approval(self) -> None:
+ from pydantic_ai import DeferredToolRequests
+
+ from codebase_rag.main import _run_agent_response_loop
+ from codebase_rag.types_defs import CHAT_LOOP_UI, ConfirmationToolNames
+
+ mock_agent = MagicMock()
+ mock_agent.run = AsyncMock(
+ side_effect=[
+ self._make_response(DeferredToolRequests(approvals=[])),
+ self._make_response("Done"),
+ ]
+ )
+ tool_names = ConfirmationToolNames(
+ replace_code="replace", create_file="create", shell_command="shell"
+ )
+ ctx, log_evt, approvals, refresh, status = self._patches()
+
+ with ctx as mock_ctx, log_evt, approvals, refresh, status:
+ mock_ctx.console.print = MagicMock()
+ mock_ctx.session.cancelled = False
+
+ await _run_agent_response_loop(
+ mock_agent,
+ [],
+ "delete first and add two",
+ CHAT_LOOP_UI,
+ tool_names,
+ )
+
+ assert mock_agent.run.call_count == 2
+ assert mock_agent.run.call_args_list[0][0][0] == "delete first and add two"
+ assert mock_agent.run.call_args_list[1][0][0] is None
+
+ @pytest.mark.asyncio
+ async def test_user_prompt_not_resent_across_multiple_deferred_rounds(
+ self,
+ ) -> None:
+ from pydantic_ai import DeferredToolRequests
+
+ from codebase_rag.main import _run_agent_response_loop
+ from codebase_rag.types_defs import CHAT_LOOP_UI, ConfirmationToolNames
+
+ mock_agent = MagicMock()
+ mock_agent.run = AsyncMock(
+ side_effect=[
+ self._make_response(DeferredToolRequests(approvals=[])),
+ self._make_response(DeferredToolRequests(approvals=[])),
+ self._make_response(DeferredToolRequests(approvals=[])),
+ self._make_response("All done"),
+ ]
+ )
+ tool_names = ConfirmationToolNames(
+ replace_code="replace", create_file="create", shell_command="shell"
+ )
+ ctx, log_evt, approvals, refresh, status = self._patches()
+
+ with ctx as mock_ctx, log_evt, approvals, refresh, status:
+ mock_ctx.console.print = MagicMock()
+ mock_ctx.session.cancelled = False
+
+ await _run_agent_response_loop(
+ mock_agent, [], "multi-step task", CHAT_LOOP_UI, tool_names
+ )
+
+ assert mock_agent.run.call_count == 4
+ assert mock_agent.run.call_args_list[0][0][0] == "multi-step task"
+ for call in mock_agent.run.call_args_list[1:]:
+ assert call[0][0] is None
+
+ @pytest.mark.asyncio
+ async def test_user_prompt_passed_on_first_call_when_no_deferred(self) -> None:
+ from codebase_rag.main import _run_agent_response_loop
+ from codebase_rag.types_defs import CHAT_LOOP_UI, ConfirmationToolNames
+
+ mock_agent = MagicMock()
+ mock_agent.run = AsyncMock(return_value=self._make_response("Hello"))
+ tool_names = ConfirmationToolNames(
+ replace_code="replace", create_file="create", shell_command="shell"
+ )
+ ctx, log_evt, approvals, refresh, status = self._patches()
+
+ with ctx as mock_ctx, log_evt, approvals, refresh, status:
+ mock_ctx.console.print = MagicMock()
+ mock_ctx.session.cancelled = False
+
+ await _run_agent_response_loop(
+ mock_agent, [], "just a question", CHAT_LOOP_UI, tool_names
+ )
+
+ assert mock_agent.run.call_count == 1
+ assert mock_agent.run.call_args_list[0][0][0] == "just a question"
+ assert mock_agent.run.call_args_list[0][1].get("deferred_tool_results") is None
+
+ @pytest.mark.asyncio
+ async def test_multimodal_user_prompt_not_resent_after_approval(self) -> None:
+ from pydantic_ai import BinaryContent, DeferredToolRequests
+
+ from codebase_rag.main import _run_agent_response_loop
+ from codebase_rag.types_defs import CHAT_LOOP_UI, ConfirmationToolNames
+
+ multimodal_prompt = [
+ "look at this image",
+ BinaryContent(data=b"\x89PNG\r\n", media_type="image/png"),
+ ]
+ mock_agent = MagicMock()
+ mock_agent.run = AsyncMock(
+ side_effect=[
+ self._make_response(DeferredToolRequests(approvals=[])),
+ self._make_response("Analyzed"),
+ ]
+ )
+ tool_names = ConfirmationToolNames(
+ replace_code="replace", create_file="create", shell_command="shell"
+ )
+ ctx, log_evt, approvals, refresh, status = self._patches()
+
+ with ctx as mock_ctx, log_evt, approvals, refresh, status:
+ mock_ctx.console.print = MagicMock()
+ mock_ctx.session.cancelled = False
+
+ await _run_agent_response_loop(
+ mock_agent, [], multimodal_prompt, CHAT_LOOP_UI, tool_names
+ )
+
+ assert mock_agent.run.call_count == 2
+ assert mock_agent.run.call_args_list[0][0][0] is multimodal_prompt
+ assert mock_agent.run.call_args_list[1][0][0] is None
+
+ @pytest.mark.asyncio
+ async def test_deferred_results_passed_only_after_approval(self) -> None:
+ from pydantic_ai import DeferredToolRequests, DeferredToolResults
+
+ from codebase_rag.main import _run_agent_response_loop
+ from codebase_rag.types_defs import CHAT_LOOP_UI, ConfirmationToolNames
+
+ approved = DeferredToolResults()
+ mock_agent = MagicMock()
+ mock_agent.run = AsyncMock(
+ side_effect=[
+ self._make_response(DeferredToolRequests(approvals=[])),
+ self._make_response("Done"),
+ ]
+ )
+ tool_names = ConfirmationToolNames(
+ replace_code="replace", create_file="create", shell_command="shell"
+ )
+
+ with (
+ patch("codebase_rag.main.app_context") as mock_ctx,
+ patch("codebase_rag.main.log_session_event"),
+ patch(
+ "codebase_rag.main._process_tool_approvals",
+ new=AsyncMock(return_value=approved),
+ ),
+ patch("codebase_rag.main._refresh_context_tokens", new=AsyncMock()),
+ patch("codebase_rag.main._thinking_with_status_bar"),
+ ):
+ mock_ctx.console.print = MagicMock()
+ mock_ctx.session.cancelled = False
+
+ await _run_agent_response_loop(
+ mock_agent, [], "edit file", CHAT_LOOP_UI, tool_names
+ )
+
+ first_kwargs = mock_agent.run.call_args_list[0][1]
+ second_kwargs = mock_agent.run.call_args_list[1][1]
+ assert first_kwargs.get("deferred_tool_results") is None
+ assert second_kwargs.get("deferred_tool_results") is approved
+
+
class TestCommandConstants:
def test_model_command_prefix(self) -> None:
assert cs.MODEL_COMMAND_PREFIX == "/model"
diff --git a/codebase_rag/tests/test_module_call_attribution.py b/codebase_rag/tests/test_module_call_attribution.py
new file mode 100644
index 000000000..9d635e0ee
--- /dev/null
+++ b/codebase_rag/tests/test_module_call_attribution.py
@@ -0,0 +1,147 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag import constants as cs
+from codebase_rag.tests.conftest import run_updater
+
+
+def _calls(mock_ingestor: MagicMock) -> list[tuple[str, str, str]]:
+ # (H) CALLS edges as (caller_label, caller_qn, callee_qn).
+ out: list[tuple[str, str, str]] = []
+ for c in mock_ingestor.ensure_relationship_batch.call_args_list:
+ if c.args[1] == cs.RelationshipType.CALLS:
+ caller_label, _caller_key, caller_qn = c.args[0]
+ _callee_label, _callee_key, callee_qn = c.args[2]
+ out.append((caller_label, caller_qn, callee_qn))
+ return out
+
+
+def _module_callees(calls: list[tuple[str, str, str]]) -> set[str]:
+ return {
+ callee.rsplit(cs.SEPARATOR_DOT, 1)[-1]
+ for label, _caller, callee in calls
+ if label == cs.NodeLabel.MODULE
+ }
+
+
+class TestModuleCallAttribution:
+ def test_nested_call_not_attributed_to_module(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "app.py").write_text(
+ "def main():\n"
+ " used_by_main()\n"
+ "\n"
+ "\n"
+ "def used_by_main():\n"
+ " return 1\n"
+ "\n"
+ "\n"
+ 'if __name__ == "__main__":\n'
+ " main()\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ calls = _calls(mock_ingestor)
+ module_callees = _module_callees(calls)
+
+ # (H) the function-body call is attributed to the function, not the module
+ assert any(
+ caller.endswith(".main") and callee.endswith(".used_by_main")
+ for _label, caller, callee in calls
+ )
+ # (H) used_by_main is only called inside main(), never at module top level
+ assert "used_by_main" not in module_callees
+
+ def test_top_level_call_is_attributed_to_module(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "app.py").write_text(
+ "def main():\n"
+ " used_by_main()\n"
+ "\n"
+ "\n"
+ "def used_by_main():\n"
+ " return 1\n"
+ "\n"
+ "\n"
+ 'if __name__ == "__main__":\n'
+ " main()\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ module_callees = _module_callees(_calls(mock_ingestor))
+
+ # (H) the `if __name__ == "__main__": main()` call runs at module load
+ assert "main" in module_callees
+
+ def test_bare_module_level_call_attributed_to_module(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "app.py").write_text(
+ "def setup():\n"
+ " return 1\n"
+ "\n"
+ "\n"
+ "def helper():\n"
+ " return 2\n"
+ "\n"
+ "\n"
+ "VALUE = setup()\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ module_callees = _module_callees(_calls(mock_ingestor))
+
+ assert "setup" in module_callees
+ # (H) helper is never called at all -> no module edge to it
+ assert "helper" not in module_callees
+
+ def test_default_argument_call_attributed_to_module(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) a default-argument expression runs at module-load (definition) time,
+ # (H) not when the function body executes, so it is a module-level call.
+ (temp_repo / "app.py").write_text(
+ "def make_default():\n"
+ " return 1\n"
+ "\n"
+ "\n"
+ "def with_default(x=make_default()):\n"
+ " return x\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="python")
+ module_callees = _module_callees(_calls(mock_ingestor))
+
+ assert "make_default" in module_callees
+
+ def test_cpp_file_scope_initializer_call_attributed_to_module(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) a C++ file-scope initializer runs at load time, so its call is
+ # (H) module-attributed; a call inside a function body is not.
+ (temp_repo / "app.cpp").write_text(
+ "int nested_cpp() { return 1; }\n"
+ "int top_cpp() { return 2; }\n"
+ "int run_cpp() { return nested_cpp(); }\n"
+ "int module_value = top_cpp();\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="cpp")
+ calls = _calls(mock_ingestor)
+ module_callees = _module_callees(calls)
+
+ assert "top_cpp" in module_callees
+ assert "nested_cpp" not in module_callees
+ assert any(
+ caller.endswith(".run_cpp") and callee.endswith(".nested_cpp")
+ for _label, caller, callee in calls
+ )
diff --git a/codebase_rag/tests/test_module_qn_language_collision.py b/codebase_rag/tests/test_module_qn_language_collision.py
new file mode 100644
index 000000000..5df31da32
--- /dev/null
+++ b/codebase_rag/tests/test_module_qn_language_collision.py
@@ -0,0 +1,79 @@
+# (H) Regression: two source files that share a basename but differ by extension
+# (H) (foo.py and foo.cpp) must get distinct module qualified names. Path-based
+# (H) module naming strips the extension, so without disambiguation both map to
+# (H) the same module qn, cascading into identical class/method qns that collapse
+# (H) under the graph's qualified_name unique constraint (dropping one file's defs).
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.constants import KEY_PATH, KEY_QUALIFIED_NAME, NodeLabel
+from codebase_rag.tests.conftest import create_and_run_updater, get_nodes
+
+
+def _make_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "mixedmod"
+ (project_path / "pkg").mkdir(parents=True)
+ (project_path / "pkg" / "shape.py").write_text(
+ encoding="utf-8",
+ data="class Shape:\n def area(self):\n return 1\n",
+ )
+ (project_path / "pkg" / "shape.cpp").write_text(
+ encoding="utf-8",
+ data="class Shape {\npublic:\n int area() {\n return 2;\n }\n};\n",
+ )
+ return project_path
+
+
+def _qns_by_path(
+ mock_ingestor: MagicMock, label: NodeLabel, name: str
+) -> dict[str, str]:
+ out: dict[str, str] = {}
+ for node in get_nodes(mock_ingestor, label):
+ props = node[0][1]
+ qn = str(props.get(KEY_QUALIFIED_NAME))
+ if qn.rsplit(".", 1)[-1] == name:
+ out[str(props.get(KEY_PATH))] = qn
+ return out
+
+
+def test_same_stem_files_get_distinct_module_qns(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = _make_project(temp_repo)
+ create_and_run_updater(project, mock_ingestor, skip_if_missing="cpp")
+
+ modules = {
+ str(node[0][1].get(KEY_PATH)): str(node[0][1].get(KEY_QUALIFIED_NAME))
+ for node in get_nodes(mock_ingestor, NodeLabel.MODULE)
+ }
+ py_mod = modules.get("pkg/shape.py")
+ cpp_mod = modules.get("pkg/shape.cpp")
+ assert py_mod and cpp_mod, f"both module nodes expected: {modules}"
+ assert py_mod != cpp_mod, f"module qn collision: {py_mod}"
+
+
+def test_same_stem_methods_do_not_collide(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = _make_project(temp_repo)
+ create_and_run_updater(project, mock_ingestor, skip_if_missing="cpp")
+
+ area = _qns_by_path(mock_ingestor, NodeLabel.METHOD, "area")
+ py_area = area.get("pkg/shape.py")
+ cpp_area = area.get("pkg/shape.cpp")
+ assert py_area and cpp_area, f"both area methods expected: {area}"
+ assert py_area != cpp_area, f"method qn collision across languages: {area}"
+
+ # (H) The method qn must derive from its own (disambiguated) module qn, not a
+ # (H) bare recomputed prefix patched up by register_unique_qn's @N dedup.
+ modules = {
+ str(node[0][1].get(KEY_PATH)): str(node[0][1].get(KEY_QUALIFIED_NAME))
+ for node in get_nodes(mock_ingestor, NodeLabel.MODULE)
+ }
+ py_mod = modules["pkg/shape.py"]
+ assert py_area.startswith(f"{py_mod}."), (
+ f"python method qn {py_area} not derived from its module {py_mod}"
+ )
+ assert "@" not in py_area, f"method qn collided and was @N-deduped: {py_area}"
diff --git a/codebase_rag/tests/test_multi_project.py b/codebase_rag/tests/test_multi_project.py
new file mode 100644
index 000000000..3755bd207
--- /dev/null
+++ b/codebase_rag/tests/test_multi_project.py
@@ -0,0 +1,126 @@
+from __future__ import annotations
+
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import MagicMock, patch
+
+import pytest
+from typer.testing import CliRunner
+
+from codebase_rag.cli import _resolve_active_projects, app
+from codebase_rag.prompts import build_rag_orchestrator_prompt
+
+runner = CliRunner()
+
+
+class TestResolveActiveProjects:
+ def test_returns_default_when_no_projects_flag(self) -> None:
+ assert _resolve_active_projects(None, "default_proj") == ["default_proj"]
+
+ def test_returns_default_for_empty_string(self) -> None:
+ assert _resolve_active_projects("", "default_proj") == ["default_proj"]
+
+ def test_single_project_in_flag(self) -> None:
+ assert _resolve_active_projects("only_one", "default_proj") == ["only_one"]
+
+ def test_multiple_projects_comma_separated(self) -> None:
+ assert _resolve_active_projects("a,b,c", "default_proj") == ["a", "b", "c"]
+
+ def test_strips_whitespace(self) -> None:
+ assert _resolve_active_projects(" a , b ,c ", "default_proj") == ["a", "b", "c"]
+
+ def test_drops_empty_entries(self) -> None:
+ assert _resolve_active_projects("a,,b,", "default_proj") == ["a", "b"]
+
+ def test_all_empty_falls_back_to_default(self) -> None:
+ assert _resolve_active_projects(",,", "default_proj") == ["default_proj"]
+
+
+class TestPromptActiveProjectsBlock:
+ def test_no_projects_lists_list_projects_hint(self) -> None:
+ prompt = build_rag_orchestrator_prompt([], active_projects=None)
+ assert "list_projects" in prompt
+ assert "Project Scope" in prompt
+
+ def test_single_project_mentions_starts_with(self) -> None:
+ prompt = build_rag_orchestrator_prompt([], active_projects=["only_one"])
+ assert "only_one" in prompt
+ assert "STARTS WITH" in prompt
+
+ def test_multiple_projects_lists_all(self) -> None:
+ prompt = build_rag_orchestrator_prompt([], active_projects=["a", "b", "c"])
+ for name in ["a", "b", "c"]:
+ assert f"`{name}`" in prompt or f"'{name}." in prompt
+ assert "STARTS WITH 'a.'" in prompt
+ assert "STARTS WITH 'b.'" in prompt
+
+
+@pytest.fixture
+def mock_memgraph_connect() -> Generator[MagicMock, None, None]:
+ with patch("codebase_rag.cli.connect_memgraph") as mock_connect:
+ mock_ingestor = MagicMock()
+ mock_connect.return_value.__enter__ = MagicMock(return_value=mock_ingestor)
+ mock_connect.return_value.__exit__ = MagicMock(return_value=False)
+ yield mock_connect
+
+
+@pytest.fixture
+def mock_sync_path() -> Generator[MagicMock, None, None]:
+ with patch("codebase_rag.cli._run_graph_sync"):
+ yield
+
+
+@pytest.fixture
+def mock_validate_models() -> Generator[None, None, None]:
+ with patch("codebase_rag.cli._update_and_validate_models"):
+ yield
+
+
+def test_start_passes_projects_to_single_query(
+ mock_memgraph_connect: MagicMock,
+ mock_sync_path: None,
+ mock_validate_models: None,
+ tmp_path: Path,
+) -> None:
+ with patch("codebase_rag.cli.main_single_query") as mock_single:
+ result = runner.invoke(
+ app,
+ [
+ "start",
+ "--repo-path",
+ str(tmp_path),
+ "--projects",
+ "alpha,beta",
+ "--ask-agent",
+ "hi",
+ "--no-sync",
+ ],
+ )
+ assert result.exit_code == 0, result.output
+ mock_single.assert_called_once()
+ assert mock_single.call_args.kwargs["active_projects"] == ["alpha", "beta"]
+
+
+def test_start_default_projects_uses_derived_name(
+ mock_memgraph_connect: MagicMock,
+ mock_sync_path: None,
+ mock_validate_models: None,
+ tmp_path: Path,
+) -> None:
+ with patch("codebase_rag.cli.main_single_query") as mock_single:
+ result = runner.invoke(
+ app,
+ [
+ "start",
+ "--repo-path",
+ str(tmp_path),
+ "--ask-agent",
+ "hi",
+ "--no-sync",
+ ],
+ )
+ assert result.exit_code == 0, result.output
+ mock_single.assert_called_once()
+ active = mock_single.call_args.kwargs["active_projects"]
+ assert len(active) == 1
+ assert "__" in active[0]
diff --git a/codebase_rag/tests/test_multiline_input_keybindings.py b/codebase_rag/tests/test_multiline_input_keybindings.py
new file mode 100644
index 000000000..d41abe943
--- /dev/null
+++ b/codebase_rag/tests/test_multiline_input_keybindings.py
@@ -0,0 +1,56 @@
+from __future__ import annotations
+
+import pytest
+from prompt_toolkit.application import create_app_session
+from prompt_toolkit.input import create_pipe_input
+from prompt_toolkit.output import DummyOutput
+
+from codebase_rag import constants as cs
+from codebase_rag.main import get_multiline_input
+
+CTRL_J = "\x0a"
+CTRL_E = "\x05"
+CTRL_C = "\x03"
+ENTER = "\r"
+
+
+def _run_with_input(text: str) -> str:
+ with create_pipe_input() as inp:
+ inp.send_text(text)
+ with create_app_session(input=inp, output=DummyOutput()):
+ return get_multiline_input("Ask")
+
+
+def test_ctrl_j_submits_buffer() -> None:
+ assert _run_with_input(f"hello{CTRL_J}") == "hello"
+
+
+def test_ctrl_e_submits_buffer() -> None:
+ assert _run_with_input(f"hello{CTRL_E}") == "hello"
+
+
+def test_ctrl_e_submits_after_multiline_with_enter() -> None:
+ assert _run_with_input(f"line1{ENTER}line2{CTRL_E}") == "line1\nline2"
+
+
+def test_ctrl_j_submits_after_multiline_with_enter() -> None:
+ assert _run_with_input(f"line1{ENTER}line2{CTRL_J}") == "line1\nline2"
+
+
+def test_result_is_stripped() -> None:
+ assert _run_with_input(f" padded {CTRL_E}") == "padded"
+
+
+def test_ctrl_c_raises_keyboard_interrupt() -> None:
+ with pytest.raises(KeyboardInterrupt):
+ _run_with_input(f"abc{CTRL_C}")
+
+
+def test_keybinding_enum_has_submit_shortcuts() -> None:
+ assert cs.KeyBinding.CTRL_J.value == "c-j"
+ assert cs.KeyBinding.CTRL_E.value == "c-e"
+
+
+def test_hint_mentions_both_submit_shortcuts() -> None:
+ assert "Ctrl+J" in cs.MULTILINE_INPUT_HINT
+ assert "Ctrl+E" in cs.MULTILINE_INPUT_HINT
diff --git a/codebase_rag/tests/test_nested_function_defines.py b/codebase_rag/tests/test_nested_function_defines.py
new file mode 100644
index 000000000..e9b9694b2
--- /dev/null
+++ b/codebase_rag/tests/test_nested_function_defines.py
@@ -0,0 +1,129 @@
+# (H) Finding #2 from the evals/ harness: a function nested inside a METHOD was
+# (H) attributed to the Module via DEFINES (flattened), producing false-positive
+# (H) module-level edges. A nested function must be DEFINES'd by its enclosing
+# (H) scope: the method for function-in-method, the function for function-in-function.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "nestproj"
+
+MODULE_SRC = """class C:
+ def find_x(self) -> int:
+ def dfs(n: int) -> int:
+ return n
+
+ return dfs(1)
+
+
+def outer() -> int:
+ def inner() -> int:
+ return 1
+
+ return inner()
+"""
+
+_RelTuple = tuple[str, PropertyValue, str, str, PropertyValue]
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.nodes: dict[tuple[str, PropertyValue], PropertyDict] = {}
+ self.rels: list[_RelTuple] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ uid = properties[cs.NODE_UNIQUE_CONSTRAINTS[label]]
+ self.nodes[(str(label), uid)] = dict(properties)
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append(
+ (
+ str(from_spec[0]),
+ from_spec[2],
+ str(rel_type),
+ str(to_spec[0]),
+ to_spec[2],
+ )
+ )
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _build(tmp_path: Path, src: str = MODULE_SRC) -> _Capture:
+ (tmp_path / "m.py").write_text(src)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return cap
+
+
+def _defines_sources(cap: _Capture, target_suffix: str) -> list[tuple[str, str]]:
+ return [
+ (from_label, str(from_val))
+ for (from_label, from_val, rel_type, _tl, target) in cap.rels
+ if rel_type == cs.RelationshipType.DEFINES
+ and str(target).endswith(target_suffix)
+ ]
+
+
+class TestNestedFunctionDefines:
+ def test_function_in_method_defined_by_method(self, tmp_path: Path) -> None:
+ cap = _build(tmp_path)
+ sources = _defines_sources(cap, ".find_x.dfs")
+ assert len(sources) == 1, sources
+ label, qn = sources[0]
+ assert label == cs.NodeLabel.METHOD, sources
+ assert qn.endswith(".C.find_x"), sources
+
+ def test_function_in_function_defined_by_function(self, tmp_path: Path) -> None:
+ cap = _build(tmp_path)
+ sources = _defines_sources(cap, ".outer.inner")
+ assert len(sources) == 1, sources
+ label, qn = sources[0]
+ assert label == cs.NodeLabel.FUNCTION, sources
+ assert qn.endswith(".outer"), sources
+
+
+CLASS_IN_METHOD_SRC = """class Holder:
+ def make(self) -> object:
+ class Local:
+ pass
+
+ return Local()
+"""
+
+
+class TestNestedClassDefines:
+ def test_class_in_method_defined_by_method(self, tmp_path: Path) -> None:
+ cap = _build(tmp_path, CLASS_IN_METHOD_SRC)
+ sources = _defines_sources(cap, ".make.Local")
+ assert len(sources) == 1, sources
+ label, qn = sources[0]
+ assert label == cs.NodeLabel.METHOD, sources
+ assert qn.endswith(".Holder.make"), sources
diff --git a/codebase_rag/tests/test_node_relationship_coverage.py b/codebase_rag/tests/test_node_relationship_coverage.py
index e6af5fd05..00389af7a 100644
--- a/codebase_rag/tests/test_node_relationship_coverage.py
+++ b/codebase_rag/tests/test_node_relationship_coverage.py
@@ -136,18 +136,15 @@ def test_each_relationship_type_can_be_flushed(
ingestor.conn = mock_conn
- ingestor.relationship_buffer.append(
- (
- (NodeLabel.MODULE.value, KEY_QUALIFIED_NAME, "module.test"),
- rel_type.value,
- (NodeLabel.FUNCTION.value, KEY_QUALIFIED_NAME, "module.test.func"),
- None,
- )
+ ingestor.ensure_relationship_batch(
+ (NodeLabel.MODULE.value, KEY_QUALIFIED_NAME, "module.test"),
+ rel_type.value,
+ (NodeLabel.FUNCTION.value, KEY_QUALIFIED_NAME, "module.test.func"),
)
ingestor.flush_relationships()
mock_cursor.execute.assert_called_once()
- assert ingestor.relationship_buffer == []
+ assert ingestor._rel_count == 0
class TestUniqueKeyPropertyNames:
@@ -230,10 +227,13 @@ def test_ensure_constraints_creates_all_constraints(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
executed_queries: list[str] = []
- def capture_query(query: str) -> None:
+ def capture_query(query: str, params: object = None) -> list[object]:
executed_queries.append(query)
+ return []
- with patch.object(ingestor, "_execute_query", side_effect=capture_query):
+ with patch.object(
+ MemgraphIngestor, "_execute_query", side_effect=capture_query
+ ):
ingestor.ensure_constraints()
for label in NodeLabel:
@@ -249,10 +249,13 @@ def test_ensure_constraints_creates_all_indexes(self) -> None:
ingestor = MemgraphIngestor(host="localhost", port=7687)
executed_queries: list[str] = []
- def capture_query(query: str) -> None:
+ def capture_query(query: str, params: object = None) -> list[object]:
executed_queries.append(query)
+ return []
- with patch.object(ingestor, "_execute_query", side_effect=capture_query):
+ with patch.object(
+ MemgraphIngestor, "_execute_query", side_effect=capture_query
+ ):
ingestor.ensure_constraints()
for label in NodeLabel:
diff --git a/codebase_rag/tests/test_operator_dispatch_resolution.py b/codebase_rag/tests/test_operator_dispatch_resolution.py
new file mode 100644
index 000000000..6f4262552
--- /dev/null
+++ b/codebase_rag/tests/test_operator_dispatch_resolution.py
@@ -0,0 +1,126 @@
+# (H) L3 finding from the evals/ harness: Python operator syntax dispatches to dunder
+# (H) methods at runtime: `k in reg` -> reg.__contains__, `reg[k]` -> reg.__getitem__,
+# (H) `reg[k] = v` -> reg.__setitem__, `len(reg)` -> reg.__len__. cgr only extracts
+# (H) call expressions, so these first-party method calls were never captured. They are
+# (H) emitted only when the operand's type resolves to a first-party class that defines
+# (H) the dunder, so builtin containers (dict/list) produce no spurious edges.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+FILES = {
+ "pkg/__init__.py": "",
+ "pkg/registry.py": (
+ "class Registry:\n"
+ " def __contains__(self, key):\n return True\n\n"
+ " def __getitem__(self, key):\n return 1\n\n"
+ " def __setitem__(self, key, value):\n return None\n\n"
+ " def __len__(self):\n return 0\n"
+ ),
+ "pkg/user.py": (
+ "from .registry import Registry\n\n\n"
+ "class User:\n"
+ " def __init__(self, reg: Registry) -> None:\n"
+ " self._reg = reg\n\n"
+ " def use(self, key):\n"
+ " if key in self._reg:\n"
+ " value = self._reg[key]\n"
+ " self._reg[key] = 1\n"
+ " return len(self._reg)\n\n"
+ " def builtin(self):\n"
+ " data = {}\n"
+ " data['x'] = 1\n"
+ " return data['x']\n"
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestOperatorDispatchResolution:
+ def test_contains_operator_dispatches_to_dunder(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.user.User.use",
+ "proj.pkg.registry.Registry.__contains__",
+ ) in calls, calls
+
+ def test_subscript_read_dispatches_to_getitem(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.user.User.use",
+ "proj.pkg.registry.Registry.__getitem__",
+ ) in calls, calls
+
+ def test_subscript_write_dispatches_to_setitem(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.user.User.use",
+ "proj.pkg.registry.Registry.__setitem__",
+ ) in calls, calls
+
+ def test_len_dispatches_to_dunder(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.user.User.use",
+ "proj.pkg.registry.Registry.__len__",
+ ) in calls, calls
+
+ def test_builtin_container_produces_no_dunder_edge(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ dunder_targets = {
+ to for (frm, to) in calls if frm == "proj.pkg.user.User.builtin"
+ }
+ assert dunder_targets == set(), dunder_targets
diff --git a/codebase_rag/tests/test_oracle_nested_defs.py b/codebase_rag/tests/test_oracle_nested_defs.py
new file mode 100644
index 000000000..e770dd1a6
--- /dev/null
+++ b/codebase_rag/tests/test_oracle_nested_defs.py
@@ -0,0 +1,46 @@
+# (H) Covers the L1 ast oracle (evals/ast_oracle.py): functions defined inside an
+# (H) except handler or a match/case block must be captured. cgr captures these
+# (H) function-local defs, so an oracle that skips them produces spurious Function
+# (H) false positives (e.g. thrift's sslcompat.py `def match` inside `except`).
+from __future__ import annotations
+
+from pathlib import Path
+
+from evals.ast_oracle import extract_oracle_graph
+
+SRC = """\
+def with_except():
+ try:
+ import something
+ except ImportError:
+ def fallback_in_except():
+ return 1
+ return fallback_in_except
+
+
+def with_match(value):
+ match value:
+ case 1:
+ def handler_in_case():
+ return 2
+ return handler_in_case
+ case _:
+ return None
+"""
+
+
+def _function_names(target: Path) -> set[str]:
+ graph = extract_oracle_graph(target, "proj")
+ return {node.name for node in graph.nodes.values() if node.key.kind == "Function"}
+
+
+def test_oracle_captures_function_in_except_handler(tmp_path: Path) -> None:
+ (tmp_path / "mod.py").write_text(SRC, encoding="utf-8")
+ names = _function_names(tmp_path)
+ assert "fallback_in_except" in names, names
+
+
+def test_oracle_captures_function_in_match_case(tmp_path: Path) -> None:
+ (tmp_path / "mod.py").write_text(SRC, encoding="utf-8")
+ names = _function_names(tmp_path)
+ assert "handler_in_case" in names, names
diff --git a/codebase_rag/tests/test_permission_mode.py b/codebase_rag/tests/test_permission_mode.py
new file mode 100644
index 000000000..f660b4a51
--- /dev/null
+++ b/codebase_rag/tests/test_permission_mode.py
@@ -0,0 +1,20 @@
+from codebase_rag.constants import PermissionMode
+from codebase_rag.models import SessionState
+
+
+class TestSessionPermissionMode:
+ def test_default_mode_is_normal(self) -> None:
+ state = SessionState()
+ assert state.permission_mode == PermissionMode.NORMAL
+ assert state.is_yolo() is False
+
+ def test_cycle_toggles_to_yolo(self) -> None:
+ state = SessionState()
+ assert state.cycle_permission_mode() == PermissionMode.YOLO
+ assert state.is_yolo() is True
+
+ def test_cycle_toggles_back_to_normal(self) -> None:
+ state = SessionState()
+ state.cycle_permission_mode()
+ assert state.cycle_permission_mode() == PermissionMode.NORMAL
+ assert state.is_yolo() is False
diff --git a/codebase_rag/tests/test_php_containment_oracle.py b/codebase_rag/tests/test_php_containment_oracle.py
new file mode 100644
index 000000000..08a38bf08
--- /dev/null
+++ b/codebase_rag/tests/test_php_containment_oracle.py
@@ -0,0 +1,66 @@
+# (H) Covers PHP containment-edge validation: cgr's DEFINES (file module ->
+# (H) every named type and top-level function) and DEFINES_METHOD (class/
+# (H) interface/trait/enum -> method) edges are graded against the independent
+# (H) php-parser oracle, joined on (kind, file, line). Exercises an interface,
+# (H) a trait, an enum with a method, a class, and a free function.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_php_graph
+from evals.oracles import php_oracle_available, run_php_oracle
+from evals.score import score_edge_types
+
+PHP_SRC = """\
+ None:
+ if not php_oracle_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.PHP not in load_parsers()[0]:
+ pytest.skip("php parser not available")
+
+
+def test_cgr_matches_php_parser_oracle_on_containment_edges(tmp_path: Path) -> None:
+ _require_php()
+ project = tmp_path / "php_edge"
+ project.mkdir()
+ (project / "lib.php").write_text(PHP_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_php_graph(project, project.name)
+ oracle = run_php_oracle(project)
+
+ result = score_edge_types(cgr, oracle, ec.SCORED_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in (
+ cs.RelationshipType.DEFINES.value,
+ cs.RelationshipType.DEFINES_METHOD.value,
+ ):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (
+ label,
+ row,
+ result.diff,
+ )
diff --git a/codebase_rag/tests/test_php_functions.py b/codebase_rag/tests/test_php_functions.py
new file mode 100644
index 000000000..992d5c900
--- /dev/null
+++ b/codebase_rag/tests/test_php_functions.py
@@ -0,0 +1,153 @@
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.tests.conftest import get_relationships
+from codebase_rag.types_defs import NodeType
+
+
+def test_php_function_discovery(temp_repo: Path, mock_ingestor: MagicMock) -> None:
+ project_path = temp_repo / "php_functions_test"
+ project_path.mkdir()
+
+ (project_path / "example.php").write_text(
+ encoding="utf-8",
+ data="""value = 0;
+ }
+
+ public function getValue() {
+ return $this->value;
+ }
+}
+
+interface MyInterface {
+ public function doSomething();
+}
+
+enum Status {
+ case Active;
+ case Inactive;
+}
+
+function standaloneFunction() {
+ $obj = new MyPhpClass();
+ return $obj->getValue();
+}
+""",
+ )
+
+ parsers, queries = load_parsers()
+ assert "php" in parsers, "PHP parser should be available"
+
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=project_path,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ created_functions = [
+ c
+ for c in mock_ingestor.ensure_node_batch.call_args_list
+ if c[0][0] == NodeType.FUNCTION
+ ]
+ fn_qns = {c[0][1]["qualified_name"] for c in created_functions}
+
+ assert any(qn.endswith(".standaloneFunction") for qn in fn_qns), fn_qns
+
+ call_rels = get_relationships(mock_ingestor, "CALLS")
+ assert len(call_rels) >= 1
+
+
+def test_php_class_discovery(temp_repo: Path, mock_ingestor: MagicMock) -> None:
+ project_path = temp_repo / "php_class_test"
+ project_path.mkdir()
+
+ (project_path / "models.php").write_text(
+ encoding="utf-8",
+ data=""" None:
+ project_path = temp_repo / "php_calls_test"
+ project_path.mkdir()
+
+ (project_path / "service.php").write_text(
+ encoding="utf-8",
+ data="""add(1, 2);
+ }
+}
+
+function main() {
+ $calc = new Calculator();
+ $calc->calculate();
+}
+""",
+ )
+
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=project_path,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ call_rels = get_relationships(mock_ingestor, "CALLS")
+ assert len(call_rels) >= 2
diff --git a/codebase_rag/tests/test_php_imports.py b/codebase_rag/tests/test_php_imports.py
new file mode 100644
index 000000000..9f8e2ef59
--- /dev/null
+++ b/codebase_rag/tests/test_php_imports.py
@@ -0,0 +1,93 @@
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.tests.conftest import get_relationships
+
+
+def test_php_use_statement_import(temp_repo: Path, mock_ingestor: MagicMock) -> None:
+ project_path = temp_repo / "php_imports_test"
+ project_path.mkdir()
+
+ (project_path / "Controller.php").write_text(
+ encoding="utf-8",
+ data="""= 1
+
+ controller_module = f"{project_path.name}.Controller"
+ import_mapping = updater.factory.import_processor.import_mapping
+ if controller_module in import_mapping:
+ mapping = import_mapping[controller_module]
+ assert "ProductService" in mapping
+ assert mapping["ProductService"] == "App.Service.ProductService"
+ assert "Repo" in mapping
+ assert mapping["Repo"] == "App.Repository.ProductRepository"
+
+
+def test_php_multiple_use_statements(temp_repo: Path, mock_ingestor: MagicMock) -> None:
+ project_path = temp_repo / "php_multi_imports"
+ project_path.mkdir()
+
+ (project_path / "app.php").write_text(
+ encoding="utf-8",
+ data=""" set[tuple[str, str]]:
+ return {
+ (call[0][0][2], call[0][2][2]) for call in get_relationships(mock_ingestor, rel)
+ }
+
+
+def test_php_inheritance_and_implements_edges(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "php_inh"
+ project.mkdir()
+ (project / "lib.php").write_text(_PHP, encoding="utf-8")
+ create_and_run_updater(project, mock_ingestor, skip_if_missing="php")
+
+ inherits = _pairs(mock_ingestor, RelationshipType.INHERITS.value)
+ implements = _pairs(mock_ingestor, RelationshipType.IMPLEMENTS.value)
+ base = "php_inh.lib"
+
+ # (H) class extends -> INHERITS.
+ assert (f"{base}.Circle", f"{base}.Base") in inherits, inherits
+ # (H) class implements -> IMPLEMENTS to each interface.
+ assert (f"{base}.Circle", f"{base}.Shape") in implements, implements
+ assert (f"{base}.Circle", f"{base}.Drawable") in implements, implements
+ # (H) interface extends -> INHERITS to each superinterface.
+ assert (f"{base}.Big", f"{base}.Shape") in inherits, inherits
+ assert (f"{base}.Big", f"{base}.Drawable") in inherits, inherits
diff --git a/codebase_rag/tests/test_php_inheritance_oracle.py b/codebase_rag/tests/test_php_inheritance_oracle.py
new file mode 100644
index 000000000..a27c33a20
--- /dev/null
+++ b/codebase_rag/tests/test_php_inheritance_oracle.py
@@ -0,0 +1,58 @@
+# (H) Covers PHP inheritance-edge validation: cgr's INHERITS (class/interface
+# (H) extends) and IMPLEMENTS (class implements) edges are graded against the
+# (H) php-parser oracle, by (source node, base SIMPLE NAME).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_php_graph
+from evals.oracles import php_oracle_available, run_php_oracle
+from evals.score import score_name_edge_types
+
+PHP_SRC = """\
+ None:
+ if not php_oracle_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.PHP not in load_parsers()[0]:
+ pytest.skip("php parser not available")
+
+
+def test_cgr_matches_php_parser_oracle_on_inheritance_edges(tmp_path: Path) -> None:
+ _require_php()
+ project = tmp_path / "php_inh_edge"
+ project.mkdir()
+ (project / "lib.php").write_text(PHP_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_php_graph(project, project.name)
+ oracle = run_php_oracle(project)
+
+ result = score_name_edge_types(cgr, oracle, ec.INHERITANCE_NAME_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in (
+ cs.RelationshipType.INHERITS.value,
+ cs.RelationshipType.IMPLEMENTS.value,
+ ):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (
+ label,
+ row,
+ result.diff,
+ )
diff --git a/codebase_rag/tests/test_php_span_oracle.py b/codebase_rag/tests/test_php_span_oracle.py
new file mode 100644
index 000000000..60b003ab8
--- /dev/null
+++ b/codebase_rag/tests/test_php_span_oracle.py
@@ -0,0 +1,74 @@
+# (H) Covers PHP node SPAN (end_line) validation: cgr's end_line for each node is
+# (H) graded against the php-parser oracle (which emits node.loc.end.line), joined
+# (H) on (kind, file, start). Exercises a class with a multi-line method, an
+# (H) interface, an enum, and a multi-line function so spans are not single line.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_php_graph
+from evals.oracles import php_oracle_available, run_php_oracle
+from evals.score import score_span
+
+PHP_SRC = """\
+size * $scale;
+ }
+}
+
+interface Shape
+{
+ public function area(int $scale): int;
+}
+
+enum Color
+{
+ case Red;
+ case Green;
+}
+
+function standalone(int $a): int
+{
+ return $a + 1;
+}
+"""
+
+
+def _require_php() -> None:
+ if not php_oracle_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.PHP not in load_parsers()[0]:
+ pytest.skip("php parser not available")
+
+
+def test_cgr_matches_php_parser_oracle_on_node_spans(tmp_path: Path) -> None:
+ _require_php()
+ project = tmp_path / "php_span_test"
+ project.mkdir()
+ (project / "lib.php").write_text(PHP_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_php_graph(project, project.name)
+ oracle = run_php_oracle(project)
+
+ result = score_span(cgr, oracle, ec.PHP_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ aggregate = by_label.get(ec.AGGREGATE_LABEL)
+ assert aggregate is not None, (by_label, result.diff)
+ assert aggregate["precision"] == 1.0 and aggregate["recall"] == 1.0, (
+ aggregate,
+ result.diff,
+ )
+ assert aggregate["tp"] >= 4, aggregate
diff --git a/codebase_rag/tests/test_php_structure_oracle.py b/codebase_rag/tests/test_php_structure_oracle.py
new file mode 100644
index 000000000..577eb14ee
--- /dev/null
+++ b/codebase_rag/tests/test_php_structure_oracle.py
@@ -0,0 +1,71 @@
+# (H) Covers the PHP structure oracle harness (evals/oracles/php_oracle +
+# (H) evals/php_l1.py): the php-parser oracle is authoritative ground truth, and
+# (H) cgr's captured PHP nodes are graded against it on (kind, file, start_line).
+# (H) Includes an attributed class (whose span starts at the attribute) and an
+# (H) anonymous class (whose methods cgr models as Functions).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_php_nodes
+from evals.oracles import php_oracle_available, run_php_oracle
+from evals.score import score_node_kinds
+from evals.types_defs import GraphData
+
+PHP_SRC = """\
+ None:
+ if not php_oracle_available():
+ pytest.skip("node/npm toolchain not available")
+ if cs.SupportedLanguage.PHP not in load_parsers()[0]:
+ pytest.skip("php parser not available")
+
+
+def test_cgr_matches_php_parser_oracle_on_php_structure(tmp_path: Path) -> None:
+ _require_php()
+ project = tmp_path / "php_oracle_test"
+ project.mkdir()
+ (project / "sample.php").write_text(PHP_SRC, encoding="utf-8")
+
+ cgr = GraphData(
+ nodes=extract_cgr_php_nodes(project, project.name),
+ edges=set(),
+ name_edges=set(),
+ )
+ oracle = run_php_oracle(project)
+
+ result = score_node_kinds(cgr, oracle, ec.PHP_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in ("Class", "Interface", "Enum", "Method", "Function"):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (label, row)
diff --git a/codebase_rag/tests/test_project_name_flag.py b/codebase_rag/tests/test_project_name_flag.py
new file mode 100644
index 000000000..214aa710c
--- /dev/null
+++ b/codebase_rag/tests/test_project_name_flag.py
@@ -0,0 +1,348 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.tests.conftest import get_node_names
+
+
+@pytest.fixture(scope="module")
+def parsers_and_queries() -> tuple[dict, dict]:
+ return load_parsers()
+
+
+def _make_updater(
+ repo_path: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ project_name: str | None = None,
+) -> GraphUpdater:
+ parsers, queries = parsers_and_queries
+ return GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=repo_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=project_name,
+ )
+
+
+def _write_python_file(repo_path: Path, rel_path: str, content: str) -> None:
+ full = repo_path / rel_path
+ full.parent.mkdir(parents=True, exist_ok=True)
+ full.write_text(content)
+
+
+class TestDefaultProjectName:
+ def test_default_uses_directory_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(temp_repo, mock_ingestor, parsers_and_queries)
+ assert updater.project_name == temp_repo.resolve().name
+
+ def test_default_none_uses_directory_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name=None
+ )
+ assert updater.project_name == temp_repo.resolve().name
+
+ def test_default_empty_string_uses_directory_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name=""
+ )
+ assert updater.project_name == temp_repo.resolve().name
+
+ def test_default_whitespace_only_uses_directory_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name=" "
+ )
+ assert updater.project_name == temp_repo.resolve().name
+
+
+class TestExplicitProjectName:
+ def test_override_simple(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="MyProject"
+ )
+ assert updater.project_name == "MyProject"
+
+ def test_override_with_hyphens(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo,
+ mock_ingestor,
+ parsers_and_queries,
+ project_name="my-cool-project",
+ )
+ assert updater.project_name == "my-cool-project"
+
+ def test_override_with_dots(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo,
+ mock_ingestor,
+ parsers_and_queries,
+ project_name="com.example.app",
+ )
+ assert updater.project_name == "com.example.app"
+
+
+class TestEdgeCases:
+ def test_generic_dir_name_src(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ src_dir = temp_repo / "src"
+ src_dir.mkdir()
+ updater = _make_updater(
+ src_dir, mock_ingestor, parsers_and_queries, project_name="BlazingRenderer"
+ )
+ assert updater.project_name == "BlazingRenderer"
+ updater_default = _make_updater(src_dir, mock_ingestor, parsers_and_queries)
+ assert updater_default.project_name == "src"
+
+ def test_generic_dir_name_main(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ main_dir = temp_repo / "main"
+ main_dir.mkdir()
+ updater = _make_updater(
+ main_dir,
+ mock_ingestor,
+ parsers_and_queries,
+ project_name="ActualProjectName",
+ )
+ assert updater.project_name == "ActualProjectName"
+
+ def test_version_named_directory(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ ver_dir = temp_repo / "v1.3.2"
+ ver_dir.mkdir()
+ updater = _make_updater(
+ ver_dir, mock_ingestor, parsers_and_queries, project_name="my-library"
+ )
+ assert updater.project_name == "my-library"
+ updater_default = _make_updater(ver_dir, mock_ingestor, parsers_and_queries)
+ assert updater_default.project_name == "v1.3.2"
+
+ def test_nested_same_name_parent(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ nested = temp_repo / "BRender" / "BlazingRenderer"
+ nested.mkdir(parents=True)
+ updater = _make_updater(
+ nested, mock_ingestor, parsers_and_queries, project_name="BlazingRenderer"
+ )
+ assert updater.project_name == "BlazingRenderer"
+
+
+class TestFactoryPropagation:
+ def test_factory_receives_project_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="CustomName"
+ )
+ assert updater.factory.project_name == "CustomName"
+
+ def test_factory_default_project_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(temp_repo, mock_ingestor, parsers_and_queries)
+ assert updater.factory.project_name == temp_repo.resolve().name
+
+ def test_structure_processor_receives_project_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="CustomName"
+ )
+ assert updater.factory.structure_processor.project_name == "CustomName"
+
+ def test_import_processor_receives_project_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="CustomName"
+ )
+ assert updater.factory.import_processor.project_name == "CustomName"
+
+ def test_definition_processor_receives_project_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="CustomName"
+ )
+ assert updater.factory.definition_processor.project_name == "CustomName"
+
+ def test_call_processor_receives_project_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="CustomName"
+ )
+ assert updater.factory.call_processor.project_name == "CustomName"
+
+ def test_type_inference_receives_project_name(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="CustomName"
+ )
+ assert updater.factory.type_inference.project_name == "CustomName"
+
+
+class TestQualifiedNameIntegration:
+ def test_module_qualified_names_use_override(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ _write_python_file(temp_repo, "hello.py", "def greet():\n pass\n")
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="MyApp"
+ )
+ updater.run(force=True)
+ module_names = get_node_names(mock_ingestor, "Module")
+ assert "MyApp.hello" in module_names
+
+ def test_function_qualified_names_use_override(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ _write_python_file(temp_repo, "utils.py", "def helper():\n return 42\n")
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="MyApp"
+ )
+ updater.run(force=True)
+ func_names = get_node_names(mock_ingestor, "Function")
+ assert "MyApp.utils.helper" in func_names
+
+ def test_class_qualified_names_use_override(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ _write_python_file(temp_repo, "models.py", "class User:\n pass\n")
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="MyApp"
+ )
+ updater.run(force=True)
+ class_names = get_node_names(mock_ingestor, "Class")
+ assert "MyApp.models.User" in class_names
+
+ def test_default_qualified_names_use_directory(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ _write_python_file(temp_repo, "foo.py", "def bar():\n pass\n")
+ updater = _make_updater(temp_repo, mock_ingestor, parsers_and_queries)
+ updater.run(force=True)
+ dir_name = temp_repo.resolve().name
+ func_names = get_node_names(mock_ingestor, "Function")
+ assert f"{dir_name}.foo.bar" in func_names
+
+ def test_package_qualified_names_use_override(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ _write_python_file(temp_repo, "pkg/__init__.py", "")
+ _write_python_file(temp_repo, "pkg/core.py", "def run():\n pass\n")
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="CustomProj"
+ )
+ updater.run(force=True)
+ func_names = get_node_names(mock_ingestor, "Function")
+ assert "CustomProj.pkg.core.run" in func_names
+
+ def test_override_vs_default_different_names(
+ self,
+ temp_repo: Path,
+ mock_ingestor: MagicMock,
+ parsers_and_queries: tuple[dict, dict],
+ ) -> None:
+ _write_python_file(temp_repo, "app.py", "def main():\n pass\n")
+ dir_name = temp_repo.resolve().name
+ updater = _make_updater(
+ temp_repo, mock_ingestor, parsers_and_queries, project_name="OverrideName"
+ )
+ updater.run(force=True)
+ func_names = get_node_names(mock_ingestor, "Function")
+ assert "OverrideName.app.main" in func_names
+ assert f"{dir_name}.app.main" not in func_names
diff --git a/codebase_rag/tests/test_project_naming.py b/codebase_rag/tests/test_project_naming.py
new file mode 100644
index 000000000..29470944a
--- /dev/null
+++ b/codebase_rag/tests/test_project_naming.py
@@ -0,0 +1,74 @@
+from pathlib import Path
+
+import pytest
+
+from codebase_rag.utils.path_utils import derive_project_name, resolve_repo_path
+
+
+def test_derive_project_name_is_stable(tmp_path: Path) -> None:
+ repo = tmp_path / "myrepo"
+ repo.mkdir()
+ first = derive_project_name(repo)
+ second = derive_project_name(repo)
+ assert first == second
+
+
+def test_derive_project_name_includes_basename(tmp_path: Path) -> None:
+ repo = tmp_path / "myrepo"
+ repo.mkdir()
+ name = derive_project_name(repo)
+ assert name.startswith("myrepo__")
+ assert len(name.split("__")[1]) == 8
+
+
+def test_derive_project_name_disambiguates_same_basename(tmp_path: Path) -> None:
+ repo_a = tmp_path / "a" / "frontend"
+ repo_b = tmp_path / "b" / "frontend"
+ repo_a.mkdir(parents=True)
+ repo_b.mkdir(parents=True)
+ assert derive_project_name(repo_a) != derive_project_name(repo_b)
+ assert derive_project_name(repo_a).startswith("frontend__")
+ assert derive_project_name(repo_b).startswith("frontend__")
+
+
+def test_derive_project_name_slugifies_special_chars(tmp_path: Path) -> None:
+ weird = tmp_path / "my repo (v2)!"
+ weird.mkdir()
+ name = derive_project_name(weird)
+ base = name.split("__")[0]
+ assert all(c.isalnum() or c in "_-" for c in base)
+
+
+def test_derive_project_name_fallback_for_root() -> None:
+ name = derive_project_name(Path("/"))
+ assert name.startswith("repo__")
+
+
+def test_resolve_repo_path_explicit_wins(tmp_path: Path) -> None:
+ repo = tmp_path / "explicit"
+ repo.mkdir()
+ resolved = resolve_repo_path(str(repo), "/some/other/path")
+ assert resolved == repo.resolve()
+
+
+def test_resolve_repo_path_uses_target_default(tmp_path: Path) -> None:
+ repo = tmp_path / "target"
+ repo.mkdir()
+ resolved = resolve_repo_path(None, str(repo))
+ assert resolved == repo.resolve()
+
+
+def test_resolve_repo_path_dot_falls_back_to_cwd(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ monkeypatch.chdir(tmp_path)
+ resolved = resolve_repo_path(None, ".")
+ assert resolved == tmp_path.resolve()
+
+
+def test_resolve_repo_path_empty_falls_back_to_cwd(
+ tmp_path: Path, monkeypatch: pytest.MonkeyPatch
+) -> None:
+ monkeypatch.chdir(tmp_path)
+ resolved = resolve_repo_path(None, "")
+ assert resolved == tmp_path.resolve()
diff --git a/codebase_rag/tests/test_property_getter_calls.py b/codebase_rag/tests/test_property_getter_calls.py
new file mode 100644
index 000000000..9168177cf
--- /dev/null
+++ b/codebase_rag/tests/test_property_getter_calls.py
@@ -0,0 +1,102 @@
+# (H) L3 finding from the evals/ harness: accessing an @property getter runs the
+# (H) getter method at runtime, but cgr saw a plain attribute access and emitted no
+# (H) CALLS edge. A property access must produce a CALLS edge to the getter method,
+# (H) while a normal attribute / method reference must not.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+MODULE_SRC = """class Engine:
+ def __init__(self) -> None:
+ self._n = 0
+
+ @property
+ def status(self) -> str:
+ return self._compute()
+
+ def _compute(self) -> str:
+ return "ok"
+
+ def check(self) -> str:
+ return self.status
+
+
+def use(e: Engine) -> str:
+ return e.status
+
+
+def plain(e: Engine) -> str:
+ return e._compute()
+"""
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "m.py").write_text(MODULE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestPropertyGetterCalls:
+ def test_property_access_via_self_is_a_call(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.Engine.check", "proj.m.Engine.status") in calls, calls
+
+ def test_property_access_via_typed_param_is_a_call(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.use", "proj.m.Engine.status") in calls, calls
+
+ def test_property_access_only_emits_the_getter_edge(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ # (H) `use` only reads e.status; no spurious edge to the unrelated _compute.
+ from_use = {to for (frm, to) in calls if frm == "proj.m.use"}
+ assert from_use == {"proj.m.Engine.status"}, from_use
+
+ def test_regular_method_call_is_unaffected(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ # (H) plain() calls a normal method, resolved by the existing call path.
+ assert ("proj.m.plain", "proj.m.Engine._compute") in calls, calls
diff --git a/codebase_rag/tests/test_property_return_type_chain.py b/codebase_rag/tests/test_property_return_type_chain.py
new file mode 100644
index 000000000..06f985764
--- /dev/null
+++ b/codebase_rag/tests/test_property_return_type_chain.py
@@ -0,0 +1,87 @@
+# (H) L3 finding from the evals/ harness: a method calls self.prop.method(), where
+# (H) self.prop is an @property whose declared return type names the class owning
+# (H) the real method. The property's return type must seed self.prop's type so the
+# (H) chained call resolves to the correct class instead of an ambiguous same-class
+# (H) method of the same name.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+MODULE_SRC = """class Worker:
+ def build(self) -> str:
+ return "real"
+
+
+class Engine:
+ @property
+ def inner(self) -> Worker:
+ return Worker()
+
+ def build(self) -> str:
+ return self.inner.build()
+"""
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "m.py").write_text(MODULE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestPropertyReturnTypeChain:
+ def test_chained_call_through_property_resolves_to_return_type_class(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.Engine.build", "proj.m.Worker.build") in calls, calls
+
+ def test_does_not_resolve_to_same_class_method_of_same_name(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.Engine.build", "proj.m.Engine.build") not in calls, calls
diff --git a/codebase_rag/tests/test_protobuf_service.py b/codebase_rag/tests/test_protobuf_service.py
index 7bb2c0de0..2b8da8a08 100644
--- a/codebase_rag/tests/test_protobuf_service.py
+++ b/codebase_rag/tests/test_protobuf_service.py
@@ -169,3 +169,130 @@ def test_protobuf_ingestor_split_index_serialization_and_deserialization(
assert rel.target_id == "test_project.UserService.get_user"
assert rel.source_label == NodeType.CLASS
assert rel.target_label == NodeType.METHOD
+
+
+def test_ensure_node_batch_no_message_class_logs_warning(tmp_path: Path) -> None:
+ from codebase_rag.services.protobuf_service import _MSG_CLASS_CACHE
+
+ output_dir = tmp_path / "out"
+ output_dir.mkdir()
+ ingestor = ProtobufFileIngestor(str(output_dir))
+
+ from codebase_rag import constants as cs
+
+ _MSG_CLASS_CACHE[cs.NodeLabel.UNION] = None
+
+ ingestor.ensure_node_batch(cs.NodeLabel.UNION, {"qualified_name": "foo.bar"})
+
+ assert "foo.bar" not in ingestor._nodes
+ _MSG_CLASS_CACHE.pop(cs.NodeLabel.UNION, None)
+
+
+def test_ensure_node_batch_no_oneof_mapping_logs_warning(tmp_path: Path) -> None:
+ from codebase_rag.services.protobuf_service import LABEL_TO_ONEOF_FIELD
+
+ output_dir = tmp_path / "out"
+ output_dir.mkdir()
+ ingestor = ProtobufFileIngestor(str(output_dir))
+
+ from codebase_rag import constants as cs
+
+ ingestor.ensure_node_batch(
+ cs.NodeLabel.PROJECT, {"name": "test_proj", "qualified_name": "test_proj"}
+ )
+ assert "test_proj" in ingestor._nodes
+
+
+def test_ensure_relationship_batch_dedup(tmp_path: Path) -> None:
+ output_dir = tmp_path / "out"
+ output_dir.mkdir()
+ ingestor = ProtobufFileIngestor(str(output_dir))
+
+ from_spec = ("Class", "qualified_name", "proj.MyClass")
+ to_spec = ("Method", "qualified_name", "proj.MyClass.method")
+ rel_type = "DEFINES_METHOD"
+
+ ingestor.ensure_relationship_batch(from_spec, rel_type, to_spec)
+ ingestor.ensure_relationship_batch(from_spec, rel_type, to_spec)
+
+ assert len(ingestor._relationships) == 1
+
+
+def test_ensure_relationship_batch_dedup_with_properties_merge(tmp_path: Path) -> None:
+ output_dir = tmp_path / "out"
+ output_dir.mkdir()
+ ingestor = ProtobufFileIngestor(str(output_dir))
+
+ from_spec = ("Class", "qualified_name", "proj.MyClass")
+ to_spec = ("Method", "qualified_name", "proj.MyClass.method")
+ rel_type = "DEFINES_METHOD"
+
+ ingestor.ensure_relationship_batch(from_spec, rel_type, to_spec)
+ ingestor.ensure_relationship_batch(from_spec, rel_type, to_spec, {"extra": "val"})
+
+ assert len(ingestor._relationships) == 1
+
+
+def test_ensure_relationship_batch_invalid_empty_source(tmp_path: Path) -> None:
+ output_dir = tmp_path / "out"
+ output_dir.mkdir()
+ ingestor = ProtobufFileIngestor(str(output_dir))
+
+ from_spec = ("Class", "qualified_name", "")
+ to_spec = ("Method", "qualified_name", "proj.MyClass.method")
+ rel_type = "DEFINES_METHOD"
+
+ ingestor.ensure_relationship_batch(from_spec, rel_type, to_spec)
+
+ assert len(ingestor._relationships) == 0
+
+
+def test_ensure_relationship_batch_invalid_empty_target(tmp_path: Path) -> None:
+ output_dir = tmp_path / "out"
+ output_dir.mkdir()
+ ingestor = ProtobufFileIngestor(str(output_dir))
+
+ from_spec = ("Class", "qualified_name", "proj.MyClass")
+ to_spec = ("Method", "qualified_name", " ")
+ rel_type = "DEFINES_METHOD"
+
+ ingestor.ensure_relationship_batch(from_spec, rel_type, to_spec)
+
+ assert len(ingestor._relationships) == 0
+
+
+def test_ensure_relationship_batch_unknown_rel_type(tmp_path: Path) -> None:
+ from codebase_rag.services.protobuf_service import _REL_TYPE_CACHE
+
+ output_dir = tmp_path / "out"
+ output_dir.mkdir()
+ ingestor = ProtobufFileIngestor(str(output_dir))
+
+ fake_rel_type = "COMPLETELY_FAKE_REL_TYPE_XYZ"
+ _REL_TYPE_CACHE.pop(fake_rel_type, None)
+
+ from_spec = ("Class", "qualified_name", "proj.A")
+ to_spec = ("Method", "qualified_name", "proj.A.b")
+
+ ingestor.ensure_relationship_batch(from_spec, fake_rel_type, to_spec)
+
+ assert len(ingestor._relationships) == 1
+ key = next(iter(ingestor._relationships))
+ rel_obj = ingestor._relationships[key]
+ assert (
+ rel_obj.type
+ == pb.Relationship.RelationshipType.RELATIONSHIP_TYPE_UNSPECIFIED
+ )
+
+
+def test_ensure_relationship_batch_none_values(tmp_path: Path) -> None:
+ output_dir = tmp_path / "out"
+ output_dir.mkdir()
+ ingestor = ProtobufFileIngestor(str(output_dir))
+
+ from_spec = ("Class", "qualified_name", None)
+ to_spec = ("Method", "qualified_name", "proj.A.b")
+
+ ingestor.ensure_relationship_batch(from_spec, "DEFINES_METHOD", to_spec)
+
+ assert len(ingestor._relationships) == 0
diff --git a/codebase_rag/tests/test_protocol_dispatch_resolution.py b/codebase_rag/tests/test_protocol_dispatch_resolution.py
new file mode 100644
index 000000000..410eaf83b
--- /dev/null
+++ b/codebase_rag/tests/test_protocol_dispatch_resolution.py
@@ -0,0 +1,123 @@
+# (H) L3 finding from the evals/ harness: DefinitionProcessor._extract_decorators calls
+# (H) self._handler.extract_decorators(node), where _handler is annotated as the Protocol
+# (H) LanguageHandler (class-level annotation) and assigned dynamically via
+# (H) get_handler(language). The runtime type is one of several conformers, so the sound
+# (H) call graph emits an edge to extract_decorators on every conformer (capturing the
+# (H) traced PythonHandler edge) and never to the Protocol stub, which never runs.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+FILES = {
+ "pkg/__init__.py": "",
+ "pkg/proto.py": (
+ "from typing import Protocol\n\n\n"
+ "class HandlerLike(Protocol):\n"
+ " def extract(self, node): ...\n"
+ ),
+ "pkg/base.py": (
+ "class BaseHandler:\n def extract(self, node):\n return []\n"
+ ),
+ "pkg/python_h.py": (
+ "from .base import BaseHandler\n\n\n"
+ "class PyHandler(BaseHandler):\n"
+ " def extract(self, node):\n"
+ " return ['py']\n"
+ ),
+ "pkg/js_h.py": (
+ "from .base import BaseHandler\n\n\n"
+ "class JsHandler(BaseHandler):\n"
+ " def extract(self, node):\n"
+ " return ['js']\n"
+ ),
+ "pkg/proc.py": (
+ "from .proto import HandlerLike\n\n\n"
+ "class Proc:\n"
+ " _handler: HandlerLike\n\n"
+ " def __init__(self, handler) -> None:\n"
+ " self._handler = handler\n\n"
+ " def go(self, node):\n"
+ " return self._handler.extract(node)\n"
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestProtocolDispatchResolution:
+ def test_dispatches_to_concrete_conformer(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.proc.Proc.go",
+ "proj.pkg.python_h.PyHandler.extract",
+ ) in calls, calls
+
+ def test_dispatches_to_all_conformers(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.proc.Proc.go",
+ "proj.pkg.js_h.JsHandler.extract",
+ ) in calls, calls
+ assert (
+ "proj.pkg.proc.Proc.go",
+ "proj.pkg.base.BaseHandler.extract",
+ ) in calls, calls
+
+ def test_does_not_emit_protocol_stub_edge(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.proc.Proc.go",
+ "proj.pkg.proto.HandlerLike.extract",
+ ) not in calls, calls
diff --git a/codebase_rag/tests/test_protocol_impl_resolution.py b/codebase_rag/tests/test_protocol_impl_resolution.py
new file mode 100644
index 000000000..a0c8036f9
--- /dev/null
+++ b/codebase_rag/tests/test_protocol_impl_resolution.py
@@ -0,0 +1,100 @@
+# (H) L3 finding from the evals/ harness: a call on a parameter typed as a
+# (H) Protocol (function_registry.get() where function_registry is a
+# (H) FunctionRegistryTrieProtocol) is traced to the concrete implementer
+# (H) (FunctionRegistryTrie), not the Protocol stub. cgr infers the Protocol
+# (H) type but stops at the stub; the XxxProtocol -> Xxx naming convention picks
+# (H) the real implementer and disambiguates it from other structural conformers
+# (H) such as a test mock.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+MODULE_SRC = """from typing import Protocol
+
+
+class StoreProtocol(Protocol):
+ def fetch(self, key: str) -> int: ...
+
+
+class Store:
+ def fetch(self, key: str) -> int:
+ return 1
+
+
+class MockStore:
+ def fetch(self, key: str) -> int:
+ return 2
+
+
+def use(store: StoreProtocol) -> int:
+ return store.fetch("x")
+"""
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "m.py").write_text(MODULE_SRC)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestProtocolImplResolution:
+ def test_protocol_typed_call_resolves_to_concrete_implementer(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.use", "proj.m.Store.fetch") in calls, calls
+
+ def test_does_not_resolve_to_protocol_stub(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.use", "proj.m.StoreProtocol.fetch") not in calls, calls
+
+ def test_naming_convention_disambiguates_from_other_conformer(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert ("proj.m.use", "proj.m.MockStore.fetch") not in calls, calls
diff --git a/codebase_rag/tests/test_protocol_operator_dispatch.py b/codebase_rag/tests/test_protocol_operator_dispatch.py
new file mode 100644
index 000000000..45c469c13
--- /dev/null
+++ b/codebase_rag/tests/test_protocol_operator_dispatch.py
@@ -0,0 +1,125 @@
+# (H) L3 finding from the evals/ harness: an operator on a Protocol-typed attribute
+# (H) (self.ast_cache[k], k in self.ast_cache) must dispatch to the dunder on the
+# (H) concrete implementer even when the implementer's name does not follow the
+# (H) XxxProtocol convention, and even when the dunder (e.g. __len__) is defined only on
+# (H) the implementer and not declared on the Protocol stub. Structural conformance
+# (H) (a class defining the Protocol's named methods) identifies the implementer.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+FILES = {
+ "pkg/__init__.py": "",
+ "pkg/proto.py": (
+ "from typing import Protocol\n\n\n"
+ "class Cache(Protocol):\n"
+ " def snapshot(self):\n ...\n\n"
+ " def __getitem__(self, key):\n ...\n\n"
+ " def __contains__(self, key):\n ...\n"
+ ),
+ # (H) MemCache does not match the Cache name convention and adds __len__, which the
+ # (H) Protocol does not declare. It conforms via the named method snapshot.
+ "pkg/impl.py": (
+ "class MemCache:\n"
+ " def snapshot(self):\n return {}\n\n"
+ " def __getitem__(self, key):\n return 1\n\n"
+ " def __contains__(self, key):\n return True\n\n"
+ " def __len__(self):\n return 0\n"
+ ),
+ "pkg/user.py": (
+ "from .proto import Cache\n\n\n"
+ "class User:\n"
+ " def __init__(self, cache: Cache) -> None:\n"
+ " self._cache = cache\n\n"
+ " def _touch(self):\n"
+ " return None\n\n"
+ " def use(self, key):\n"
+ " self._touch()\n"
+ " if key in self._cache:\n"
+ " return self._cache[key]\n"
+ " return len(self._cache)\n"
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestProtocolOperatorDispatch:
+ def test_subscript_and_membership_reach_structural_conformer(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.user.User.use",
+ "proj.pkg.impl.MemCache.__getitem__",
+ ) in calls, calls
+ assert (
+ "proj.pkg.user.User.use",
+ "proj.pkg.impl.MemCache.__contains__",
+ ) in calls, calls
+
+ def test_dunder_only_on_implementer_resolves(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.user.User.use",
+ "proj.pkg.impl.MemCache.__len__",
+ ) in calls, calls
+
+ def test_protocol_stub_not_emitted(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.user.User.use",
+ "proj.pkg.proto.Cache.__getitem__",
+ ) not in calls, calls
diff --git a/codebase_rag/tests/test_provider_classes.py b/codebase_rag/tests/test_provider_classes.py
index 1475914a0..da492ebd7 100644
--- a/codebase_rag/tests/test_provider_classes.py
+++ b/codebase_rag/tests/test_provider_classes.py
@@ -9,6 +9,8 @@
from codebase_rag.constants import GoogleProviderType, Provider
from codebase_rag.providers.base import (
+ AnthropicProvider,
+ AzureOpenAIProvider,
GoogleProvider,
ModelProvider,
OllamaProvider,
@@ -37,16 +39,42 @@ def test_get_valid_providers(self) -> None:
assert isinstance(ollama_provider, OllamaProvider)
assert ollama_provider.provider_name == Provider.OLLAMA
+ anthropic_provider = get_provider(Provider.ANTHROPIC, api_key="test-key")
+ assert isinstance(anthropic_provider, AnthropicProvider)
+ assert anthropic_provider.provider_name == Provider.ANTHROPIC
+
+ azure_provider = get_provider(
+ Provider.AZURE,
+ api_key="test-key",
+ endpoint="https://myresource.openai.azure.com",
+ )
+ assert isinstance(azure_provider, AzureOpenAIProvider)
+ assert azure_provider.provider_name == Provider.AZURE
+
def test_get_invalid_provider(self) -> None:
with pytest.raises(ValueError, match="Unknown provider 'invalid_provider'"):
get_provider("invalid_provider")
+ def test_get_litellm_provider(self) -> None:
+ litellm_provider = get_provider(
+ Provider.LITELLM_PROXY,
+ api_key="sk-test",
+ endpoint="http://localhost:4000/v1",
+ )
+ from codebase_rag.providers.litellm import LiteLLMProvider
+
+ assert isinstance(litellm_provider, LiteLLMProvider)
+ assert litellm_provider.provider_name == Provider.LITELLM_PROXY
+
def test_list_providers(self) -> None:
providers = list_providers()
assert Provider.GOOGLE in providers
assert Provider.OPENAI in providers
assert Provider.OLLAMA in providers
- assert len(providers) >= 3
+ assert Provider.ANTHROPIC in providers
+ assert Provider.AZURE in providers
+ assert Provider.LITELLM_PROXY in providers
+ assert len(providers) >= 6
def test_register_custom_provider(self) -> None:
class CustomProvider(ModelProvider):
@@ -190,6 +218,107 @@ def test_ollama_validation_connection_error(self, mock_client: Any) -> None:
provider.validate_config()
+class TestAnthropicProvider:
+ def test_anthropic_configuration(self) -> None:
+ provider = AnthropicProvider(api_key="sk-ant-test-key")
+ assert provider.provider_name == Provider.ANTHROPIC
+ assert provider.api_key == "sk-ant-test-key"
+ provider.validate_config()
+
+ def test_anthropic_validation_error(self) -> None:
+ provider = AnthropicProvider()
+ with pytest.raises(ValueError, match="Anthropic provider requires api_key"):
+ provider.validate_config()
+
+ @patch("codebase_rag.providers.base.PydanticAnthropicProvider")
+ @patch("codebase_rag.providers.base.AnthropicModel")
+ def test_anthropic_model_creation(
+ self, mock_anthropic_model: Any, mock_anthropic_provider: Any
+ ) -> None:
+ provider = AnthropicProvider(api_key="sk-ant-test-key")
+ mock_model = MagicMock()
+ mock_anthropic_model.return_value = mock_model
+ result = provider.create_model("claude-opus-4-6")
+ mock_anthropic_model.assert_called_once()
+ assert result == mock_model
+
+ @patch("codebase_rag.providers.base.PydanticAnthropicProvider")
+ @patch("codebase_rag.providers.base.AnthropicModel")
+ def test_anthropic_model_enables_prompt_caching(
+ self, mock_anthropic_model: Any, mock_anthropic_provider: Any
+ ) -> None:
+ provider = AnthropicProvider(api_key="sk-ant-test-key")
+ provider.create_model("claude-opus-4-7")
+
+ settings_arg = mock_anthropic_model.call_args.kwargs["settings"]
+ assert settings_arg["anthropic_cache_instructions"] is True
+ assert settings_arg["anthropic_cache_tool_definitions"] is True
+ assert settings_arg["anthropic_cache_messages"] is True
+
+ def test_anthropic_api_key_from_env(self) -> None:
+ with patch.dict("os.environ", {"ANTHROPIC_API_KEY": "env-key"}):
+ provider = AnthropicProvider()
+ assert provider.api_key == "env-key"
+
+
+class TestAzureOpenAIProvider:
+ def test_azure_configuration(self) -> None:
+ provider = AzureOpenAIProvider(
+ api_key="azure-key",
+ endpoint="https://myresource.openai.azure.com",
+ api_version="2024-06-01",
+ )
+ assert provider.provider_name == Provider.AZURE
+ assert provider.api_key == "azure-key"
+ assert provider.endpoint == "https://myresource.openai.azure.com"
+ assert provider.api_version == "2024-06-01"
+ provider.validate_config()
+
+ def test_azure_validation_error_no_key(self) -> None:
+ provider = AzureOpenAIProvider(endpoint="https://myresource.openai.azure.com")
+ with pytest.raises(ValueError, match="Azure OpenAI provider requires api_key"):
+ provider.validate_config()
+
+ def test_azure_validation_error_no_endpoint(self) -> None:
+ provider = AzureOpenAIProvider(api_key="azure-key")
+ with pytest.raises(ValueError, match="Azure OpenAI provider requires endpoint"):
+ provider.validate_config()
+
+ @patch("codebase_rag.providers.base.PydanticAzureProvider")
+ @patch("codebase_rag.providers.base.OpenAIChatModel")
+ def test_azure_model_creation(
+ self, mock_chat_model: Any, mock_azure_provider: Any
+ ) -> None:
+ provider = AzureOpenAIProvider(
+ api_key="azure-key",
+ endpoint="https://myresource.openai.azure.com",
+ )
+ mock_model = MagicMock()
+ mock_chat_model.return_value = mock_model
+ result = provider.create_model("gpt-4o")
+ mock_azure_provider.assert_called_once_with(
+ api_key="azure-key",
+ azure_endpoint="https://myresource.openai.azure.com",
+ api_version=None,
+ )
+ mock_chat_model.assert_called_once_with(
+ "gpt-4o", provider=mock_azure_provider.return_value
+ )
+ assert result == mock_model
+
+ def test_azure_api_key_from_env(self) -> None:
+ with patch.dict(
+ "os.environ",
+ {
+ "AZURE_API_KEY": "env-key",
+ "AZURE_OPENAI_ENDPOINT": "https://env.openai.azure.com",
+ },
+ ):
+ provider = AzureOpenAIProvider()
+ assert provider.api_key == "env-key"
+ assert provider.endpoint == "https://env.openai.azure.com"
+
+
class TestModelCreation:
@patch("codebase_rag.providers.base.PydanticGoogleProvider")
@patch("codebase_rag.providers.base.GoogleModel")
@@ -275,3 +404,109 @@ def test_ollama_model_creation(
mock_openai_provider.assert_called_once_with(
api_key="ollama", base_url="http://localhost:11434/v1"
)
+
+
+class TestLiteLLMProvider:
+ def test_litellm_configuration(self) -> None:
+ from codebase_rag.providers.litellm import LiteLLMProvider
+
+ provider = LiteLLMProvider(
+ api_key="sk-litellm-key", endpoint="http://litellm:4000/v1"
+ )
+ assert provider.provider_name == Provider.LITELLM_PROXY
+ assert provider.api_key == "sk-litellm-key"
+ assert provider.endpoint == "http://litellm:4000/v1"
+
+ def test_litellm_default_endpoint(self) -> None:
+ from codebase_rag.providers.litellm import LiteLLMProvider
+
+ provider = LiteLLMProvider()
+ assert provider.endpoint == "http://localhost:4000/v1"
+
+ def test_litellm_no_endpoint_validation_error(self) -> None:
+ from codebase_rag.providers.litellm import LiteLLMProvider
+
+ provider = LiteLLMProvider(endpoint="")
+ with pytest.raises(ValueError, match="LiteLLM provider requires endpoint"):
+ provider.validate_config()
+
+ @patch("httpx.Client")
+ def test_litellm_validation_success(self, mock_client: Any) -> None:
+ from codebase_rag.providers.litellm import LiteLLMProvider
+
+ mock_response = MagicMock()
+ mock_response.status_code = 200
+ mock_client.return_value.__enter__.return_value.get.return_value = mock_response
+
+ provider = LiteLLMProvider(api_key="sk-test", endpoint="http://litellm:4000/v1")
+ provider.validate_config()
+
+ @patch("httpx.Client")
+ def test_litellm_validation_server_not_running(self, mock_client: Any) -> None:
+ from codebase_rag.providers.litellm import LiteLLMProvider
+
+ mock_response = MagicMock()
+ mock_response.status_code = 404
+ mock_client.return_value.__enter__.return_value.get.return_value = mock_response
+
+ provider = LiteLLMProvider(endpoint="http://litellm:4000/v1")
+ with pytest.raises(ValueError, match="LiteLLM proxy server not responding"):
+ provider.validate_config()
+
+ @patch("httpx.Client")
+ def test_litellm_validation_fallback_to_models_endpoint(
+ self, mock_client: Any
+ ) -> None:
+ from codebase_rag.providers.litellm import LiteLLMProvider
+
+ health_response = MagicMock()
+ health_response.status_code = 401
+ models_response = MagicMock()
+ models_response.status_code = 200
+ mock_client.return_value.__enter__.return_value.get.side_effect = [
+ health_response,
+ models_response,
+ ]
+
+ provider = LiteLLMProvider(api_key="sk-test", endpoint="http://litellm:4000/v1")
+ provider.validate_config()
+
+ @patch("httpx.Client")
+ def test_litellm_validation_connection_error(self, mock_client: Any) -> None:
+ import httpx
+
+ from codebase_rag.providers.litellm import LiteLLMProvider
+
+ mock_client.return_value.__enter__.return_value.get.side_effect = (
+ httpx.ConnectError("Connection failed")
+ )
+
+ provider = LiteLLMProvider(endpoint="http://litellm:4000/v1")
+ with pytest.raises(ValueError, match="LiteLLM proxy server not responding"):
+ provider.validate_config()
+
+ @patch("codebase_rag.providers.litellm.PydanticLiteLLMProvider")
+ @patch("codebase_rag.providers.litellm.OpenAIChatModel")
+ @patch("httpx.Client")
+ def test_litellm_model_creation(
+ self, mock_client: Any, mock_chat_model: Any, mock_litellm_provider: Any
+ ) -> None:
+ from codebase_rag.providers.litellm import LiteLLMProvider
+
+ mock_response = MagicMock()
+ mock_response.status_code = 200
+ mock_client.return_value.__enter__.return_value.get.return_value = mock_response
+
+ provider = LiteLLMProvider(api_key="sk-test", endpoint="http://litellm:4000/v1")
+ mock_model = MagicMock()
+ mock_chat_model.return_value = mock_model
+
+ result = provider.create_model("openai/gpt-4o")
+
+ mock_litellm_provider.assert_called_once_with(
+ api_key="sk-test", api_base="http://litellm:4000/v1"
+ )
+ mock_chat_model.assert_called_once_with(
+ "openai/gpt-4o", provider=mock_litellm_provider.return_value
+ )
+ assert result == mock_model
diff --git a/codebase_rag/tests/test_py_variable_analyzer_integration.py b/codebase_rag/tests/test_py_variable_analyzer_integration.py
index 93b9f7fbb..ca193ee39 100644
--- a/codebase_rag/tests/test_py_variable_analyzer_integration.py
+++ b/codebase_rag/tests/test_py_variable_analyzer_integration.py
@@ -596,3 +596,88 @@ def _find_node_recursive(self, node, node_type: str, name: str):
if result:
return result
return None
+
+
+def _find_func_node(root_node, func_name: str):
+ stack = [root_node]
+ while stack:
+ node = stack.pop()
+ if node.type == "function_definition":
+ name_node = node.child_by_field_name("name")
+ if name_node and name_node.text.decode() == func_name:
+ return node
+ stack.extend(reversed(node.children))
+ return None
+
+
+class TestTraverseSinglePassWithQueries:
+ @pytest.fixture
+ def engine_with_queries(
+ self,
+ import_processor: MagicMock,
+ mock_function_registry: MagicMock,
+ mock_ast_cache: MagicMock,
+ ) -> PythonTypeInferenceEngine:
+ from codebase_rag import constants as cs
+ from codebase_rag.parser_loader import load_parsers
+
+ parsers, queries = load_parsers()
+ if cs.SupportedLanguage.PYTHON not in parsers:
+ pytest.skip("Python parser not available")
+
+ return PythonTypeInferenceEngine(
+ import_processor=import_processor,
+ function_registry=mock_function_registry,
+ repo_path=Path("/test/repo"),
+ project_name="test_project",
+ ast_cache=mock_ast_cache,
+ queries=queries,
+ module_qn_to_file_path={},
+ class_inheritance={},
+ simple_name_lookup=defaultdict(set),
+ js_type_inference_getter=lambda: MagicMock(),
+ )
+
+ def test_traverse_with_query_path(
+ self,
+ python_parser: Parser,
+ engine_with_queries: PythonTypeInferenceEngine,
+ ) -> None:
+ python_code = b"""
+def process(name: str, count: int) -> None:
+ result = name.upper()
+ items = []
+ for i in range(count):
+ items.append(i)
+"""
+ tree = python_parser.parse(python_code)
+ func_node = _find_func_node(tree.root_node, "process")
+ assert func_node is not None
+
+ result = engine_with_queries.build_local_variable_type_map(
+ func_node, "test.module"
+ )
+
+ assert "name" in result
+ assert result["name"] == "str"
+ assert "count" in result
+ assert result["count"] == "int"
+
+ def test_traverse_with_query_path_caches_return_stmts(
+ self,
+ python_parser: Parser,
+ engine_with_queries: PythonTypeInferenceEngine,
+ ) -> None:
+ python_code = b"""
+def get_value(x: int) -> int:
+ return x + 1
+"""
+ tree = python_parser.parse(python_code)
+ func_node = _find_func_node(tree.root_node, "get_value")
+ assert func_node is not None
+
+ engine_with_queries.build_local_variable_type_map(func_node, "test.module")
+
+ return_nodes: list = []
+ engine_with_queries._find_return_statements(func_node, return_nodes)
+ assert len(return_nodes) >= 1
diff --git a/codebase_rag/tests/test_python_nested_functions.py b/codebase_rag/tests/test_python_nested_functions.py
index 66f64b989..2a164d94d 100644
--- a/codebase_rag/tests/test_python_nested_functions.py
+++ b/codebase_rag/tests/test_python_nested_functions.py
@@ -318,10 +318,6 @@ def main():
def test_function_in_class_method(
nested_functions_project: Path, mock_ingestor: MagicMock
) -> None:
- """Test that functions inside class methods are properly handled.
-
- Note: Functions inside methods are currently treated as methods rather than nested functions.
- """
parsers, queries = load_parsers()
updater = GraphUpdater(
@@ -333,21 +329,51 @@ def test_function_in_class_method(
updater.run()
project_name = nested_functions_project.name
-
- expected_method_qn = f"{project_name}.nested_functions.OuterClass.nested_in_method"
-
created_methods = get_node_names(mock_ingestor, "Method")
- assert expected_method_qn in created_methods, (
- f"Function in method not found as method: {expected_method_qn}"
+ assert (
+ f"{project_name}.nested_functions.OuterClass.method_with_nested"
+ in created_methods
+ )
+
+ nested_qn = f"{project_name}.nested_functions.OuterClass.nested_in_method"
+ assert nested_qn not in created_methods, (
+ f"Nested function inside method should not be ingested as class method: {nested_qn}"
)
- expected_class_methods = [
- f"{project_name}.nested_functions.OuterClass.method_with_nested",
- f"{project_name}.nested_functions.OuterClass.nested_in_method",
- ]
- for expected_method in expected_class_methods:
- assert expected_method in created_methods, (
- f"Expected method not found: {expected_method}"
+def test_nested_function_in_staticmethod_not_ingested_as_method(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project_path = temp_repo / "static_nested"
+ os.makedirs(project_path)
+ (project_path / "__init__.py").touch()
+
+ with open(project_path / "api.py", "w") as f:
+ f.write(
+ "class Api:\n"
+ " @staticmethod\n"
+ " def say_hello():\n"
+ " def test_func():\n"
+ ' print("api")\n'
+ " pass\n"
)
+
+ parsers, queries = load_parsers()
+ updater = GraphUpdater(
+ ingestor=mock_ingestor,
+ repo_path=project_path,
+ parsers=parsers,
+ queries=queries,
+ )
+ updater.run()
+
+ project_name = project_path.name
+ created_methods = get_node_names(mock_ingestor, "Method")
+
+ assert f"{project_name}.api.Api.say_hello" in created_methods
+
+ bad_qn = f"{project_name}.api.Api.test_func"
+ assert bad_qn not in created_methods, (
+ f"Nested function inside staticmethod should not be ingested as class method: {bad_qn}"
+ )
diff --git a/codebase_rag/tests/test_python_real_world.py b/codebase_rag/tests/test_python_real_world.py
index 770014655..0243e2f04 100644
--- a/codebase_rag/tests/test_python_real_world.py
+++ b/codebase_rag/tests/test_python_real_world.py
@@ -874,24 +874,20 @@ class PlainTaskSchema(Schema):
return project_path
-def test_flask_model_calls(
+def test_flask_no_calls_to_class_nodes(
todo_app_project: Path,
mock_ingestor: MagicMock,
) -> None:
- """Test detection of model usage in controllers."""
+ """Test that Class nodes are not targets of CALLS relationships."""
run_updater(todo_app_project, mock_ingestor)
function_calls = get_relationships(mock_ingestor, "CALLS")
- model_usage_calls = [
- call
- for call in function_calls
- if "task_controller" in call.args[0][2] and "TaskModel" in call.args[2][2]
- ]
+ class_calls = [call for call in function_calls if call.args[2][0] == "Class"]
- assert model_usage_calls, (
- f"Expected TaskController to use TaskModel, found: "
- f"{[(c.args[0][2], c.args[2][2]) for c in model_usage_calls]}"
+ assert not class_calls, (
+ f"Expected no CALLS edges to Class nodes, found: "
+ f"{[(c.args[0][2], c.args[2][2]) for c in class_calls]}"
)
diff --git a/codebase_rag/tests/test_python_relative_import_resolution.py b/codebase_rag/tests/test_python_relative_import_resolution.py
index 883dd1d97..6b305b690 100644
--- a/codebase_rag/tests/test_python_relative_import_resolution.py
+++ b/codebase_rag/tests/test_python_relative_import_resolution.py
@@ -43,7 +43,7 @@ def test_single_dot_relative_import(self, mock_updater: GraphUpdater) -> None:
module_qn,
)
- expected = "pkg.sub1.sub2.utils"
+ expected = "myproject.pkg.sub1.sub2.utils"
assert result == expected
def test_double_dot_relative_import(self, mock_updater: GraphUpdater) -> None:
@@ -66,7 +66,7 @@ def test_double_dot_relative_import(self, mock_updater: GraphUpdater) -> None:
module_qn,
)
- expected = "pkg.sub1.shared"
+ expected = "myproject.pkg.sub1.shared"
assert result == expected
def test_triple_dot_relative_import(self, mock_updater: GraphUpdater) -> None:
@@ -89,7 +89,7 @@ def test_triple_dot_relative_import(self, mock_updater: GraphUpdater) -> None:
module_qn,
)
- expected = "pkg.common"
+ expected = "myproject.pkg.common"
assert result == expected
def test_relative_import_to_package_root(self, mock_updater: GraphUpdater) -> None:
@@ -112,7 +112,7 @@ def test_relative_import_to_package_root(self, mock_updater: GraphUpdater) -> No
module_qn,
)
- expected = "config"
+ expected = "myproject.config"
assert result == expected
def test_relative_import_without_module_name(
@@ -133,7 +133,7 @@ def test_relative_import_without_module_name(
module_qn,
)
- expected = "pkg.sub1"
+ expected = "myproject.pkg.sub1"
assert result == expected
def test_relative_import_edge_case_shallow_module(
@@ -158,7 +158,7 @@ def test_relative_import_edge_case_shallow_module(
module_qn,
)
- expected = "other"
+ expected = "myproject.other"
assert result == expected
def test_relative_import_complex_module_path(
@@ -183,5 +183,5 @@ def test_relative_import_complex_module_path(
module_qn,
)
- expected = "pkg.sub1.sub2.helpers.database.models"
+ expected = "myproject.pkg.sub1.sub2.helpers.database.models"
assert result == expected
diff --git a/codebase_rag/tests/test_python_span_oracle.py b/codebase_rag/tests/test_python_span_oracle.py
new file mode 100644
index 000000000..f2e51219a
--- /dev/null
+++ b/codebase_rag/tests/test_python_span_oracle.py
@@ -0,0 +1,71 @@
+# (H) Covers Python L1 node SPAN (end_line) validation: cgr's end_line for each
+# (H) Class/Function/Method is graded against the ast oracle (node.end_lineno) via
+# (H) the L1 score(), joined on (kind, file, start). Exercises a decorated
+# (H) multi-line def, a property, an async multi-line signature, and a nested
+# (H) function so spans are not trivially single line.
+from __future__ import annotations
+
+from pathlib import Path
+
+from evals import constants as ec
+from evals.ast_oracle import extract_oracle_graph
+from evals.cgr_graph import extract_cgr_graph
+from evals.score import score
+
+PY_SRC = '''\
+import functools
+
+
+@functools.cache
+def decorated(
+ a: int,
+ b: int,
+) -> int:
+ return a + b
+
+
+class Widget:
+ """doc."""
+
+ @property
+ def size(self) -> int:
+ return self._n
+
+ async def fetch(
+ self,
+ url: str,
+ ) -> str:
+ return await call(url)
+
+
+def outer():
+ def inner():
+ return 1
+
+ return inner
+'''
+
+
+def test_cgr_matches_ast_oracle_on_python_node_spans(tmp_path: Path) -> None:
+ project = tmp_path / "py_span"
+ project.mkdir()
+ (project / "m.py").write_text(PY_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_graph(project, project.name)
+ oracle = extract_oracle_graph(project, project.name)
+
+ result = score(cgr, oracle)
+ span_rows = {
+ row["label"]: row
+ for row in result.rows
+ if row["category"] == ec.Category.SPAN.value
+ }
+ # (H) score() must now emit graded span rows for Class/Function/Method.
+ assert span_rows, [r["category"] for r in result.rows]
+ aggregate = span_rows.get(ec.AGGREGATE_LABEL)
+ assert aggregate is not None, span_rows
+ assert aggregate["precision"] == 1.0 and aggregate["recall"] == 1.0, (
+ aggregate,
+ result.diff,
+ )
+ assert aggregate["tp"] >= 5, aggregate
diff --git a/codebase_rag/tests/test_python_standard_library_imports.py b/codebase_rag/tests/test_python_standard_library_imports.py
index c7cfa891e..98ec5f673 100644
--- a/codebase_rag/tests/test_python_standard_library_imports.py
+++ b/codebase_rag/tests/test_python_standard_library_imports.py
@@ -11,10 +11,10 @@ class TestStandardLibraryImports:
"""Test import resolution for standard library vs local modules."""
@pytest.fixture
- def mock_updater(self) -> GraphUpdater:
+ def mock_updater(self, tmp_path: Path) -> GraphUpdater:
mock_ingestor = MagicMock()
- test_repo = Path("/tmp/myproject")
+ test_repo = tmp_path / "myproject"
test_repo.mkdir(exist_ok=True)
(test_repo / "utils").mkdir(exist_ok=True)
diff --git a/codebase_rag/tests/test_query_truncation.py b/codebase_rag/tests/test_query_truncation.py
new file mode 100644
index 000000000..57f582c69
--- /dev/null
+++ b/codebase_rag/tests/test_query_truncation.py
@@ -0,0 +1,76 @@
+from __future__ import annotations
+
+from unittest.mock import AsyncMock, MagicMock, patch
+
+import pytest
+
+from codebase_rag.tools.codebase_query import create_query_tool
+from codebase_rag.types_defs import ResultRow
+
+
+@pytest.fixture
+def mock_ingestor() -> MagicMock:
+ return MagicMock()
+
+
+@pytest.fixture
+def mock_cypher_gen() -> MagicMock:
+ gen = MagicMock()
+ gen.generate = AsyncMock(return_value="MATCH (n) RETURN n")
+ return gen
+
+
+class TestQueryTruncation:
+ @pytest.mark.asyncio
+ async def test_row_cap_truncation(
+ self, mock_ingestor: MagicMock, mock_cypher_gen: MagicMock
+ ) -> None:
+ rows: list[ResultRow] = [{"name": f"node_{i}"} for i in range(600)]
+ mock_ingestor.fetch_all.return_value = rows
+
+ tool = create_query_tool(mock_ingestor, mock_cypher_gen)
+ with patch("codebase_rag.tools.codebase_query.settings") as mock_settings:
+ mock_settings.QUERY_RESULT_ROW_CAP = 500
+ mock_settings.QUERY_RESULT_MAX_TOKENS = 100000
+ mock_settings.QUERY_TIMEOUT_S = 60.0
+ result = await tool.function(natural_language_query="list all nodes")
+
+ assert len(result.results) <= 500
+ assert "truncated" in result.summary.lower() or "600" in result.summary
+
+ @pytest.mark.asyncio
+ async def test_token_truncation(
+ self, mock_ingestor: MagicMock, mock_cypher_gen: MagicMock
+ ) -> None:
+ rows: list[ResultRow] = [
+ {"name": f"function_{i}", "body": f"def func_{i}(): pass # {'x' * 200}"}
+ for i in range(100)
+ ]
+ mock_ingestor.fetch_all.return_value = rows
+
+ tool = create_query_tool(mock_ingestor, mock_cypher_gen)
+ with patch("codebase_rag.tools.codebase_query.settings") as mock_settings:
+ mock_settings.QUERY_RESULT_ROW_CAP = 500
+ mock_settings.QUERY_RESULT_MAX_TOKENS = 500
+ mock_settings.QUERY_TIMEOUT_S = 60.0
+ result = await tool.function(natural_language_query="list functions")
+
+ assert len(result.results) < 100
+ assert "truncated" in result.summary.lower()
+
+ @pytest.mark.asyncio
+ async def test_no_truncation_when_within_limits(
+ self, mock_ingestor: MagicMock, mock_cypher_gen: MagicMock
+ ) -> None:
+ rows: list[ResultRow] = [{"name": f"node_{i}"} for i in range(5)]
+ mock_ingestor.fetch_all.return_value = rows
+
+ tool = create_query_tool(mock_ingestor, mock_cypher_gen)
+ with patch("codebase_rag.tools.codebase_query.settings") as mock_settings:
+ mock_settings.QUERY_RESULT_ROW_CAP = 500
+ mock_settings.QUERY_RESULT_MAX_TOKENS = 16000
+ mock_settings.QUERY_TIMEOUT_S = 60.0
+ result = await tool.function(natural_language_query="small query")
+
+ assert len(result.results) == 5
+ assert "Successfully" in result.summary
diff --git a/codebase_rag/tests/test_realtime_debounce.py b/codebase_rag/tests/test_realtime_debounce.py
new file mode 100644
index 000000000..eee1fcf48
--- /dev/null
+++ b/codebase_rag/tests/test_realtime_debounce.py
@@ -0,0 +1,445 @@
+"""
+Tests for the realtime_updater debouncing functionality.
+
+These tests verify the hybrid debounce strategy that prevents redundant
+graph updates during rapid file saves.
+"""
+
+from __future__ import annotations
+
+import threading
+import time
+from pathlib import Path
+from typing import Any
+from unittest.mock import MagicMock
+
+import pytest
+from watchdog.events import FileCreatedEvent, FileDeletedEvent, FileModifiedEvent
+
+from codebase_rag.constants import DEFAULT_DEBOUNCE_SECONDS, DEFAULT_MAX_WAIT_SECONDS
+from codebase_rag.services import QueryProtocol
+
+
+class MockQueryIngestor:
+ def __init__(self) -> None:
+ self.execute_write = MagicMock()
+ self.flush_all = MagicMock()
+ self.fetch_all = MagicMock(return_value=[])
+ self.ensure_node_batch = MagicMock()
+ self.ensure_relationship_batch = MagicMock()
+
+ def __enter__(self) -> MockQueryIngestor:
+ return self
+
+ def __exit__(self, *args: Any) -> None:
+ pass
+
+
+# Register MockQueryIngestor as implementing QueryProtocol for isinstance checks
+QueryProtocol.register(MockQueryIngestor)
+
+
+class TestCodeChangeEventHandlerDebounce:
+ @pytest.fixture(autouse=True)
+ def _patch_ignore(self, monkeypatch: pytest.MonkeyPatch) -> None:
+ from codebase_rag import constants as cs
+
+ patched = cs.IGNORE_PATTERNS - {"tmp"}
+ monkeypatch.setattr(cs, "IGNORE_PATTERNS", patched)
+ monkeypatch.setattr("realtime_updater.IGNORE_PATTERNS", patched)
+
+ @pytest.fixture
+ def mock_ingestor(self) -> MockQueryIngestor:
+ return MockQueryIngestor()
+
+ @pytest.fixture
+ def mock_updater(
+ self, tmp_path: Path, mock_ingestor: MockQueryIngestor
+ ) -> MagicMock:
+ updater = MagicMock()
+ updater.repo_path = tmp_path
+ updater.ingestor = mock_ingestor
+ updater.remove_file_from_state = MagicMock()
+ updater.factory = MagicMock()
+ updater.factory.definition_processor.process_file = MagicMock(return_value=None)
+ updater._process_function_calls = MagicMock()
+ updater.parsers = {}
+ updater.queries = {}
+ updater.ast_cache = {}
+ return updater
+
+ @pytest.fixture
+ def sample_file(self, tmp_path: Path) -> Path:
+ test_file = tmp_path / "test.py"
+ test_file.write_text("# test file")
+ return test_file
+
+ def test_handler_initialization_with_debounce(
+ self, mock_updater: MagicMock
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=5, max_wait_seconds=30
+ )
+
+ assert handler.debounce_seconds == 5
+ assert handler.max_wait_seconds == 30
+ assert handler.debounce_enabled is True
+ assert len(handler.timers) == 0
+ assert len(handler.first_event_time) == 0
+ assert len(handler.pending_events) == 0
+
+ def test_handler_initialization_without_debounce(
+ self, mock_updater: MagicMock
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0, max_wait_seconds=30
+ )
+
+ assert handler.debounce_seconds == 0
+ assert handler.debounce_enabled is False
+
+ def test_handler_uses_default_constants(self, mock_updater: MagicMock) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(mock_updater)
+
+ assert handler.debounce_seconds == DEFAULT_DEBOUNCE_SECONDS
+ assert handler.max_wait_seconds == DEFAULT_MAX_WAIT_SECONDS
+
+ def test_is_relevant_filters_ignored_patterns(
+ self, mock_updater: MagicMock, tmp_path: Path
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(mock_updater)
+
+ # Should be ignored (directories in ignore patterns)
+ assert handler._is_relevant(str(tmp_path / ".git" / "config")) is False
+ assert handler._is_relevant(str(tmp_path / "node_modules" / "pkg.js")) is False
+ assert handler._is_relevant(str(tmp_path / "__pycache__" / "mod.pyc")) is False
+
+ # Should be relevant
+ assert handler._is_relevant(str(tmp_path / "main.py")) is True
+ assert handler._is_relevant(str(tmp_path / "src" / "lib.rs")) is True
+ assert handler._is_relevant(str(tmp_path / "app.js")) is True
+
+ def test_dispatch_ignores_directories(
+ self, mock_updater: MagicMock, mock_ingestor: MockQueryIngestor, tmp_path: Path
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0.1, max_wait_seconds=1
+ )
+
+ # Create event that is marked as directory
+ event = FileModifiedEvent(str(tmp_path / "some_dir"))
+ # The is_directory property is set by watchdog based on the event type
+ # For FileModifiedEvent, we need to check is_directory attribute
+ object.__setattr__(event, "is_directory", True)
+
+ handler.dispatch(event)
+
+ # No timer should be created for directory events
+ assert len(handler.timers) == 0
+ mock_ingestor.execute_write.assert_not_called()
+
+ def test_debounce_batches_rapid_events(
+ self,
+ mock_updater: MagicMock,
+ mock_ingestor: MockQueryIngestor,
+ sample_file: Path,
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0.2, max_wait_seconds=5
+ )
+
+ # Simulate 5 rapid saves
+ for _ in range(5):
+ event = FileModifiedEvent(str(sample_file))
+ handler.dispatch(event)
+ time.sleep(0.05) # 50ms between saves
+
+ # Should have one pending event
+ assert len(handler.pending_events) == 1
+
+ # Wait for debounce to complete
+ time.sleep(0.4)
+
+ # After debounce, ingestor should have been called only once
+ mock_ingestor.flush_all.assert_called_once()
+
+ def test_no_debounce_processes_immediately(
+ self,
+ mock_updater: MagicMock,
+ mock_ingestor: MockQueryIngestor,
+ sample_file: Path,
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0, max_wait_seconds=30
+ )
+
+ event = FileModifiedEvent(str(sample_file))
+ handler.dispatch(event)
+
+ # Should process immediately (no pending events)
+ assert len(handler.pending_events) == 0
+ assert len(handler.timers) == 0
+ mock_ingestor.flush_all.assert_called_once()
+
+ def test_max_wait_forces_update(
+ self,
+ mock_updater: MagicMock,
+ mock_ingestor: MockQueryIngestor,
+ sample_file: Path,
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0.5, max_wait_seconds=0.3
+ )
+
+ # First event
+ event = FileModifiedEvent(str(sample_file))
+ handler.dispatch(event)
+
+ # Wait until max_wait is exceeded
+ time.sleep(0.4)
+
+ # Second event should trigger immediate processing due to max_wait
+ event2 = FileModifiedEvent(str(sample_file))
+ handler.dispatch(event2)
+
+ # Give time for processing
+ time.sleep(0.15)
+
+ # Should have processed at least once due to max_wait
+ assert mock_ingestor.flush_all.call_count >= 1
+
+ def test_different_files_tracked_separately(
+ self, mock_updater: MagicMock, tmp_path: Path
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ file1 = tmp_path / "file1.py"
+ file2 = tmp_path / "file2.py"
+ file1.write_text("# file 1")
+ file2.write_text("# file 2")
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0.2, max_wait_seconds=5
+ )
+
+ # Events for different files
+ event1 = FileModifiedEvent(str(file1))
+ event2 = FileModifiedEvent(str(file2))
+
+ handler.dispatch(event1)
+ handler.dispatch(event2)
+
+ # Should have two pending events
+ assert len(handler.pending_events) == 2
+ assert len(handler.timers) == 2
+
+ def test_timer_cleanup_after_processing(
+ self,
+ mock_updater: MagicMock,
+ mock_ingestor: MockQueryIngestor,
+ sample_file: Path,
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0.1, max_wait_seconds=5
+ )
+
+ event = FileModifiedEvent(str(sample_file))
+ handler.dispatch(event)
+
+ # Should have pending state
+ assert len(handler.pending_events) == 1
+ assert len(handler.first_event_time) == 1
+
+ # Wait for processing
+ time.sleep(0.25)
+
+ # State should be cleaned up
+ assert len(handler.pending_events) == 0
+ assert len(handler.first_event_time) == 0
+ assert len(handler.timers) == 0
+
+ def test_created_event_triggers_debounce(
+ self, mock_updater: MagicMock, tmp_path: Path
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ new_file = tmp_path / "new_file.py"
+ new_file.write_text("# new file")
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0.2, max_wait_seconds=5
+ )
+
+ event = FileCreatedEvent(str(new_file))
+ handler.dispatch(event)
+
+ assert len(handler.pending_events) == 1
+
+ def test_deleted_event_triggers_debounce(
+ self, mock_updater: MagicMock, sample_file: Path
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0.2, max_wait_seconds=5
+ )
+
+ event = FileDeletedEvent(str(sample_file))
+ handler.dispatch(event)
+
+ assert len(handler.pending_events) == 1
+
+ def test_thread_safety_concurrent_events(
+ self, mock_updater: MagicMock, tmp_path: Path
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=5.0, max_wait_seconds=30
+ )
+
+ files = [tmp_path / f"file{i}.py" for i in range(10)]
+ for f in files:
+ f.write_text(f"# {f.name}")
+
+ def send_events(file_path: Path) -> None:
+ for _ in range(5):
+ event = FileModifiedEvent(str(file_path))
+ handler.dispatch(event)
+ time.sleep(0.02)
+
+ # Send events from multiple threads
+ threads = [threading.Thread(target=send_events, args=(f,)) for f in files[:5]]
+ for t in threads:
+ t.start()
+ for t in threads:
+ t.join()
+
+ # Should have 5 pending events (one per file)
+ assert len(handler.pending_events) == 5
+
+
+class TestDebounceValidation:
+ def test_validate_non_negative_float_accepts_zero(self) -> None:
+ from realtime_updater import _validate_non_negative_float
+
+ assert _validate_non_negative_float(0) == 0
+ assert _validate_non_negative_float(0.0) == 0.0
+
+ def test_validate_non_negative_float_accepts_positive(self) -> None:
+ from realtime_updater import _validate_non_negative_float
+
+ assert _validate_non_negative_float(5) == 5
+ assert _validate_non_negative_float(0.5) == 0.5
+ assert _validate_non_negative_float(100) == 100
+
+ def test_validate_non_negative_float_rejects_negative(self) -> None:
+ import typer
+
+ from realtime_updater import _validate_non_negative_float
+
+ with pytest.raises(typer.BadParameter):
+ _validate_non_negative_float(-1)
+
+ with pytest.raises(typer.BadParameter):
+ _validate_non_negative_float(-0.1)
+
+
+class TestDebounceIntegration:
+ @pytest.fixture(autouse=True)
+ def _patch_ignore(self, monkeypatch: pytest.MonkeyPatch) -> None:
+ from codebase_rag import constants as cs
+
+ patched = cs.IGNORE_PATTERNS - {"tmp"}
+ monkeypatch.setattr(cs, "IGNORE_PATTERNS", patched)
+ monkeypatch.setattr("realtime_updater.IGNORE_PATTERNS", patched)
+
+ @pytest.fixture
+ def mock_ingestor(self) -> MockQueryIngestor:
+ return MockQueryIngestor()
+
+ @pytest.fixture
+ def mock_updater(
+ self, tmp_path: Path, mock_ingestor: MockQueryIngestor
+ ) -> MagicMock:
+ updater = MagicMock()
+ updater.repo_path = tmp_path
+ updater.ingestor = mock_ingestor
+ updater.remove_file_from_state = MagicMock()
+ updater.factory = MagicMock()
+ updater.factory.definition_processor.process_file = MagicMock(return_value=None)
+ updater._process_function_calls = MagicMock()
+ updater.parsers = {}
+ updater.queries = {}
+ updater.ast_cache = {}
+ return updater
+
+ def test_realistic_rapid_save_scenario(
+ self, mock_updater: MagicMock, mock_ingestor: MockQueryIngestor, tmp_path: Path
+ ) -> None:
+ """
+ Simulate realistic rapid save scenario:
+ - User saves file 10 times over 3 seconds
+ - With 0.5s debounce and 2s max_wait, should result in ~2-4 updates
+ """
+ from realtime_updater import CodeChangeEventHandler
+
+ test_file = tmp_path / "editor.py"
+ test_file.write_text("# editing")
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0.5, max_wait_seconds=2
+ )
+
+ # Simulate 10 saves over 3 seconds
+ for i in range(10):
+ event = FileModifiedEvent(str(test_file))
+ handler.dispatch(event)
+ time.sleep(0.3)
+
+ # Wait for final debounce
+ time.sleep(0.7)
+
+ # Should have batched into fewer updates due to max_wait and debounce
+ # With max_wait=2s and 3s total time, expect ~2-4 updates
+ call_count = mock_ingestor.flush_all.call_count
+ assert 1 <= call_count <= 4, f"Expected 1-4 updates, got {call_count}"
+
+ def test_single_edit_after_quiet_period(
+ self, mock_updater: MagicMock, mock_ingestor: MockQueryIngestor, tmp_path: Path
+ ) -> None:
+ from realtime_updater import CodeChangeEventHandler
+
+ test_file = tmp_path / "single.py"
+ test_file.write_text("# single edit")
+
+ handler = CodeChangeEventHandler(
+ mock_updater, debounce_seconds=0.1, max_wait_seconds=5
+ )
+
+ event = FileModifiedEvent(str(test_file))
+ handler.dispatch(event)
+
+ # Wait for debounce
+ time.sleep(0.25)
+
+ # Should have exactly one update
+ mock_ingestor.flush_all.assert_called_once()
diff --git a/codebase_rag/tests/test_realtime_event_filtering.py b/codebase_rag/tests/test_realtime_event_filtering.py
new file mode 100644
index 000000000..68f641d93
--- /dev/null
+++ b/codebase_rag/tests/test_realtime_event_filtering.py
@@ -0,0 +1,210 @@
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Protocol, runtime_checkable
+from unittest.mock import MagicMock
+
+import pytest
+from watchdog.events import (
+ FileClosedNoWriteEvent,
+ FileCreatedEvent,
+ FileDeletedEvent,
+ FileModifiedEvent,
+ FileOpenedEvent,
+ FileSystemEvent,
+)
+
+from codebase_rag import constants as cs
+from realtime_updater import CodeChangeEventHandler
+
+
+@runtime_checkable
+class _AnyProtocol(Protocol):
+ pass
+
+
+@pytest.fixture(autouse=True)
+def _bypass_protocol_check(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setattr("realtime_updater.QueryProtocol", _AnyProtocol)
+
+
+@pytest.fixture
+def handler(mock_updater: MagicMock) -> CodeChangeEventHandler:
+ h = CodeChangeEventHandler(mock_updater, debounce_seconds=0)
+ h.ignore_patterns = h.ignore_patterns - {"tmp", "temp"}
+ return h
+
+
+def _make_event(event_type: str, src_path: str) -> FileSystemEvent:
+ ev = MagicMock(spec=FileSystemEvent)
+ ev.event_type = event_type
+ ev.src_path = src_path
+ ev.is_directory = False
+ return ev
+
+
+class TestEventFiltering:
+ def test_modified_event_is_processed(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "app.py"
+ f.write_text("x = 1", encoding="utf-8")
+ handler.dispatch(FileModifiedEvent(str(f)))
+ assert mock_updater.ingestor.execute_write.call_count == 3
+
+ def test_created_event_is_processed(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "new.py"
+ f.write_text("y = 2", encoding="utf-8")
+ handler.dispatch(FileCreatedEvent(str(f)))
+ assert mock_updater.ingestor.execute_write.call_count == 3
+ mock_updater.ingestor.flush_all.assert_called_once()
+
+ def test_deleted_event_is_processed(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "gone.py"
+ handler.dispatch(FileDeletedEvent(str(f)))
+ assert mock_updater.ingestor.execute_write.call_count == 3
+ mock_updater.factory.definition_processor.process_file.assert_not_called()
+ mock_updater.factory.structure_processor.process_generic_file.assert_not_called()
+
+ def test_opened_event_is_ignored(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "read_only.py"
+ f.touch()
+ handler.dispatch(FileOpenedEvent(str(f)))
+ mock_updater.ingestor.execute_write.assert_not_called()
+ mock_updater.ingestor.flush_all.assert_not_called()
+
+ def test_closed_no_write_event_is_ignored(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "viewed.py"
+ f.touch()
+ handler.dispatch(FileClosedNoWriteEvent(str(f)))
+ mock_updater.ingestor.execute_write.assert_not_called()
+ mock_updater.ingestor.flush_all.assert_not_called()
+
+ def test_access_event_is_ignored(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "accessed.py"
+ f.touch()
+ ev = _make_event("access", str(f))
+ handler.dispatch(ev)
+ mock_updater.ingestor.execute_write.assert_not_called()
+ mock_updater.ingestor.flush_all.assert_not_called()
+
+
+class TestNonCodeFileHandling:
+ def test_markdown_file_creates_file_node(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "readme.md"
+ f.write_text("# Title", encoding="utf-8")
+ handler.dispatch(FileCreatedEvent(str(f)))
+ mock_updater.factory.structure_processor.process_generic_file.assert_called_once_with(
+ f, "readme.md"
+ )
+
+ def test_json_file_creates_file_node(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "config.json"
+ f.write_text("{}", encoding="utf-8")
+ handler.dispatch(FileCreatedEvent(str(f)))
+ mock_updater.factory.structure_processor.process_generic_file.assert_called_once_with(
+ f, "config.json"
+ )
+
+ def test_non_code_file_deletion_removes_file_node(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "notes.md"
+ handler.dispatch(FileDeletedEvent(str(f)))
+ delete_file_calls = [
+ c
+ for c in mock_updater.ingestor.execute_write.call_args_list
+ if c.args[0] == cs.CYPHER_DELETE_FILE
+ ]
+ assert len(delete_file_calls) == 1
+ assert delete_file_calls[0].args[1] == {
+ cs.KEY_PATH: "notes.md",
+ }
+ mock_updater.factory.structure_processor.process_generic_file.assert_not_called()
+
+ def test_non_code_file_has_no_module_node(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "data.md"
+ f.write_text("text", encoding="utf-8")
+ handler.dispatch(FileCreatedEvent(str(f)))
+ mock_updater.factory.definition_processor.process_file.assert_not_called()
+
+
+class TestMixedEventSequences:
+ def test_rapid_create_modify_delete(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f = temp_repo / "ephemeral.py"
+ f.write_text("a = 1", encoding="utf-8")
+ handler.dispatch(FileCreatedEvent(str(f)))
+
+ mock_updater.ingestor.reset_mock()
+ mock_updater.factory.reset_mock()
+ f.write_text("a = 2", encoding="utf-8")
+ handler.dispatch(FileModifiedEvent(str(f)))
+
+ mock_updater.ingestor.reset_mock()
+ mock_updater.factory.reset_mock()
+ handler.dispatch(FileDeletedEvent(str(f)))
+
+ # (H) After delete, no re-parse or file node creation
+ mock_updater.factory.definition_processor.process_file.assert_not_called()
+ mock_updater.factory.structure_processor.process_generic_file.assert_not_called()
+ assert mock_updater.ingestor.execute_write.call_count == 3
+ mock_updater.ingestor.flush_all.assert_called_once()
+
+ def test_multiple_files_changed(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f1 = temp_repo / "a.py"
+ f2 = temp_repo / "b.py"
+ f1.write_text("x = 1", encoding="utf-8")
+ f2.write_text("y = 2", encoding="utf-8")
+
+ handler.dispatch(FileModifiedEvent(str(f1)))
+ handler.dispatch(FileModifiedEvent(str(f2)))
+
+ assert mock_updater.ingestor.execute_write.call_count == 6
+ assert mock_updater.ingestor.flush_all.call_count == 2
+
+
+class TestCypherDeleteFileQuery:
+ def test_delete_file_only_targets_specific_path(
+ self, handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
+ ) -> None:
+ f1 = temp_repo / "keep.py"
+ f2 = temp_repo / "remove.py"
+ f1.write_text("a = 1", encoding="utf-8")
+
+ handler.dispatch(FileDeletedEvent(str(f2)))
+
+ delete_file_calls = [
+ c
+ for c in mock_updater.ingestor.execute_write.call_args_list
+ if c.args[0] == cs.CYPHER_DELETE_FILE
+ ]
+ assert len(delete_file_calls) == 1
+ assert delete_file_calls[0].args[1] == {cs.KEY_PATH: "remove.py"}
+
+ delete_module_calls = [
+ c
+ for c in mock_updater.ingestor.execute_write.call_args_list
+ if c.args[0] == cs.CYPHER_DELETE_MODULE
+ ]
+ assert len(delete_module_calls) == 1
+ assert delete_module_calls[0].args[1] == {cs.KEY_PATH: "remove.py"}
diff --git a/codebase_rag/tests/test_realtime_updater.py b/codebase_rag/tests/test_realtime_updater.py
index c53b5b6ae..fdf1b604a 100644
--- a/codebase_rag/tests/test_realtime_updater.py
+++ b/codebase_rag/tests/test_realtime_updater.py
@@ -1,4 +1,7 @@
+from __future__ import annotations
+
from pathlib import Path
+from typing import Protocol, runtime_checkable
from unittest.mock import MagicMock
import pytest
@@ -12,10 +15,21 @@
from realtime_updater import CodeChangeEventHandler
+@runtime_checkable
+class _AnyProtocol(Protocol):
+ pass
+
+
+@pytest.fixture(autouse=True)
+def _bypass_protocol_check(monkeypatch: pytest.MonkeyPatch) -> None:
+ monkeypatch.setattr("realtime_updater.QueryProtocol", _AnyProtocol)
+
+
@pytest.fixture
def event_handler(mock_updater: MagicMock) -> CodeChangeEventHandler:
- """Provides a CodeChangeEventHandler instance with a mocked updater."""
- return CodeChangeEventHandler(mock_updater)
+ handler = CodeChangeEventHandler(mock_updater, debounce_seconds=0)
+ handler.ignore_patterns = handler.ignore_patterns - {"tmp", "temp"}
+ return handler
def test_file_creation_flow(
@@ -28,7 +42,8 @@ def test_file_creation_flow(
event_handler.dispatch(event)
- assert mock_updater.ingestor.execute_write.call_count == 2
+ # (H) 3 execute_write calls: DELETE_MODULE, DELETE_FILE, DELETE_CALLS
+ assert mock_updater.ingestor.execute_write.call_count == 3
mock_updater.factory.definition_processor.process_file.assert_called_once_with(
test_file,
"python",
@@ -48,7 +63,8 @@ def test_file_modification_flow(
event_handler.dispatch(event)
- assert mock_updater.ingestor.execute_write.call_count == 2
+ # (H) 3 execute_write calls: DELETE_MODULE, DELETE_FILE, DELETE_CALLS
+ assert mock_updater.ingestor.execute_write.call_count == 3
mock_updater.factory.definition_processor.process_file.assert_called_once_with(
test_file,
"python",
@@ -67,7 +83,8 @@ def test_file_deletion_flow(
event_handler.dispatch(event)
- assert mock_updater.ingestor.execute_write.call_count == 2
+ # (H) 3 execute_write calls: DELETE_MODULE, DELETE_FILE, DELETE_CALLS
+ assert mock_updater.ingestor.execute_write.call_count == 3
mock_updater.factory.definition_processor.process_file.assert_not_called()
mock_updater.ingestor.flush_all.assert_called_once()
@@ -103,16 +120,22 @@ def test_directory_creation_is_ignored(
mock_updater.ingestor.flush_all.assert_not_called()
-def test_unsupported_file_types_are_ignored(
+def test_non_code_files_create_file_nodes(
event_handler: CodeChangeEventHandler, mock_updater: MagicMock, temp_repo: Path
) -> None:
- """Test that changing an unsupported file type is ignored after deletion query."""
- unsupported_file = temp_repo / "document.md"
- unsupported_file.write_text(encoding="utf-8", data="# Markdown file")
- event = FileModifiedEvent(str(unsupported_file))
+ """Test that non-code files (like .md) create File nodes but skip AST parsing."""
+ non_code_file = temp_repo / "document.md"
+ non_code_file.write_text(encoding="utf-8", data="# Markdown file")
+ event = FileModifiedEvent(str(non_code_file))
event_handler.dispatch(event)
- assert mock_updater.ingestor.execute_write.call_count == 2
+ # (H) 3 execute_write calls: DELETE_MODULE, DELETE_FILE, DELETE_CALLS
+ assert mock_updater.ingestor.execute_write.call_count == 3
+ # (H) AST parsing is skipped for non-code files
mock_updater.factory.definition_processor.process_file.assert_not_called()
+ # (H) But File node creation IS called for all file types
+ mock_updater.factory.structure_processor.process_generic_file.assert_called_once_with(
+ non_code_file, "document.md"
+ )
mock_updater.ingestor.flush_all.assert_called_once()
diff --git a/codebase_rag/tests/test_reconcile_embeddings.py b/codebase_rag/tests/test_reconcile_embeddings.py
new file mode 100644
index 000000000..0e69f646e
--- /dev/null
+++ b/codebase_rag/tests/test_reconcile_embeddings.py
@@ -0,0 +1,94 @@
+from collections.abc import Generator
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+from loguru import logger
+
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.services.graph_service import MemgraphIngestor
+
+
+@pytest.fixture
+def updater(temp_repo: Path) -> GraphUpdater:
+ mock = MagicMock(spec=MemgraphIngestor)
+ mock.fetch_all = MagicMock(return_value=[])
+ parsers, queries = load_parsers()
+ return GraphUpdater(
+ ingestor=mock,
+ repo_path=temp_repo,
+ parsers=parsers,
+ queries=queries,
+ )
+
+
+@pytest.fixture
+def log_messages() -> Generator[list[str], None, None]:
+ messages: list[str] = []
+ handler_id = logger.add(lambda msg: messages.append(str(msg)), level="DEBUG")
+ yield messages
+ logger.remove(handler_id)
+
+
+class TestReconcileEmbeddings:
+ def test_noop_when_expected_empty(self, updater: GraphUpdater) -> None:
+ mock_fn = MagicMock()
+ updater._reconcile_embeddings(set(), mock_fn)
+ mock_fn.assert_not_called()
+
+ def test_logs_ok_when_all_found(
+ self, updater: GraphUpdater, log_messages: list[str]
+ ) -> None:
+ expected = {1, 2, 3}
+ mock_fn = MagicMock(return_value={1, 2, 3})
+
+ updater._reconcile_embeddings(expected, mock_fn)
+
+ mock_fn.assert_called_once_with(expected)
+ combined = "\n".join(log_messages)
+ assert "all 3 expected embeddings found" in combined
+
+ def test_logs_warning_when_ids_missing(
+ self, updater: GraphUpdater, log_messages: list[str]
+ ) -> None:
+ expected = {1, 2, 3, 4, 5}
+ mock_fn = MagicMock(return_value={1, 3})
+
+ updater._reconcile_embeddings(expected, mock_fn)
+
+ combined = "\n".join(log_messages)
+ assert "3 of 5 embeddings missing" in combined
+
+ def test_sample_ids_in_warning(
+ self, updater: GraphUpdater, log_messages: list[str]
+ ) -> None:
+ expected = {10, 20, 30}
+ mock_fn = MagicMock(return_value={10})
+
+ updater._reconcile_embeddings(expected, mock_fn)
+
+ combined = "\n".join(log_messages)
+ assert "20" in combined
+ assert "30" in combined
+
+ def test_handles_verify_fn_exception(
+ self, updater: GraphUpdater, log_messages: list[str]
+ ) -> None:
+ mock_fn = MagicMock(side_effect=RuntimeError("connection lost"))
+
+ updater._reconcile_embeddings({1, 2}, mock_fn)
+
+ combined = "\n".join(log_messages).lower()
+ assert "reconciliation check failed" in combined
+
+ def test_sample_limited_to_ten(
+ self, updater: GraphUpdater, log_messages: list[str]
+ ) -> None:
+ expected = set(range(20))
+ mock_fn = MagicMock(return_value=set())
+
+ updater._reconcile_embeddings(expected, mock_fn)
+
+ combined = "\n".join(log_messages)
+ assert "20 of 20 embeddings missing" in combined
diff --git a/codebase_rag/tests/test_reexport_chain_resolution.py b/codebase_rag/tests/test_reexport_chain_resolution.py
new file mode 100644
index 000000000..b9a6a8d65
--- /dev/null
+++ b/codebase_rag/tests/test_reexport_chain_resolution.py
@@ -0,0 +1,110 @@
+# (H) L3 finding from the evals/ harness: TypeInferenceEngine.build_local_variable_type_map
+# (H) calls self.python_type_inference.build_local_variable_type_map(...), where the
+# (H) python_type_inference property returns PythonTypeInferenceEngine imported via a
+# (H) package re-export (from .py import PythonTypeInferenceEngine). The caller's import
+# (H) map points the name at the re-export module, not the class's real definition, so
+# (H) the chained method must follow the re-export hop to resolve to the concrete class
+# (H) rather than collapsing to an ambiguous same-named method (the caller itself).
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+# (H) PythonEngine lives in pkg/py/engine.py and is re-exported from pkg/py/__init__.py.
+# (H) A sibling JsEngine.build_map exists so the bare name is ambiguous in the trie.
+FILES = {
+ "pkg/__init__.py": "",
+ "pkg/py/__init__.py": "from .engine import PythonEngine\n\n__all__ = ['PythonEngine']\n",
+ "pkg/py/engine.py": (
+ "class PythonEngine:\n def build_map(self, node):\n return {}\n"
+ ),
+ "pkg/js_engine.py": (
+ "class JsEngine:\n def build_map(self, node):\n return {}\n"
+ ),
+ "pkg/dispatch.py": (
+ "from .py import PythonEngine\n\n\n"
+ "class Dispatch:\n"
+ " def __init__(self) -> None:\n"
+ " self._python_engine = None\n\n"
+ " @property\n"
+ " def python_engine(self) -> PythonEngine:\n"
+ " if self._python_engine is None:\n"
+ " self._python_engine = PythonEngine()\n"
+ " return self._python_engine\n\n"
+ " def build_map(self, node):\n"
+ " return self.python_engine.build_map(node)\n"
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestReexportChainResolution:
+ def test_property_typed_by_reexport_resolves_to_real_class(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.dispatch.Dispatch.build_map",
+ "proj.pkg.py.engine.PythonEngine.build_map",
+ ) in calls, calls
+
+ def test_does_not_collapse_to_caller_same_named_method(
+ self, tmp_path: Path
+ ) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.dispatch.Dispatch.build_map",
+ "proj.pkg.dispatch.Dispatch.build_map",
+ ) not in calls, calls
diff --git a/codebase_rag/tests/test_relative_import_package_init.py b/codebase_rag/tests/test_relative_import_package_init.py
new file mode 100644
index 000000000..d6b12a8be
--- /dev/null
+++ b/codebase_rag/tests/test_relative_import_package_init.py
@@ -0,0 +1,72 @@
+# (H) L2 residual from the evals/ harness: relative imports inside an __init__.py
+# (H) resolved one level too high. A package's qualified name IS the package, so
+# (H) `from . import sub` in pkg/__init__.py must target pkg.sub, not the parent.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _import_edges(
+ tmp_path: Path,
+) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "__init__.py").touch()
+ pkg = tmp_path / "pkg"
+ pkg.mkdir()
+ pkg.joinpath("__init__.py").write_text("from . import sub\n\nuse = sub\n")
+ pkg.joinpath("sub.py").write_text("X = 1\n")
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.IMPORTS
+ }
+
+
+class TestRelativeImportPackageInit:
+ def test_from_dot_import_in_package_init_targets_own_submodule(
+ self, tmp_path: Path
+ ) -> None:
+ edges = _import_edges(tmp_path)
+ assert ("proj.pkg", "proj.pkg.sub") in edges, edges
+ assert ("proj.pkg", "proj.sub") not in edges, edges
diff --git a/codebase_rag/tests/test_relative_import_root_level.py b/codebase_rag/tests/test_relative_import_root_level.py
new file mode 100644
index 000000000..68146e489
--- /dev/null
+++ b/codebase_rag/tests/test_relative_import_root_level.py
@@ -0,0 +1,70 @@
+# (H) L2 finding from the evals/ harness: `from . import ` at the
+# (H) package root (e.g. cli.py doing `from . import constants as cs`) produced
+# (H) no IMPORTS edge, because relative-import resolution dropped the project
+# (H) name and computed an empty base module. In a subpackage it worked.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _imports(
+ tmp_path: Path, importer: str, src: str
+) -> set[tuple[PropertyValue, PropertyValue]]:
+ (tmp_path / "__init__.py").touch()
+ (tmp_path / "constants.py").write_text("X = 1\n")
+ (tmp_path / importer).write_text(src)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.IMPORTS
+ }
+
+
+class TestRelativeImportRootLevel:
+ def test_from_dot_import_submodule_at_root(self, tmp_path: Path) -> None:
+ edges = _imports(
+ tmp_path, "cli.py", "from . import constants as cs\n\nuse = cs\n"
+ )
+ assert ("proj.cli", "proj.constants") in edges, edges
diff --git a/codebase_rag/tests/test_rust.py b/codebase_rag/tests/test_rust.py
index 0751458e6..14f534809 100644
--- a/codebase_rag/tests/test_rust.py
+++ b/codebase_rag/tests/test_rust.py
@@ -302,25 +302,43 @@ def test_rust_structs_enums_unions(
project_name = rust_project.name
- expected_classes = [
+ expected_structs = [
f"{project_name}.types.Point",
f"{project_name}.types.Color",
f"{project_name}.types.Unit",
f"{project_name}.types.Container",
f"{project_name}.types.Borrowed",
f"{project_name}.types.GenericBorrowed",
+ ]
+
+ created_classes = get_node_names(mock_ingestor, "Class")
+
+ missing_structs = set(expected_structs) - created_classes
+ assert not missing_structs, (
+ f"Missing expected structs: {sorted(list(missing_structs))}"
+ )
+
+ expected_enums = [
f"{project_name}.types.Direction",
f"{project_name}.types.Message",
f"{project_name}.types.Option",
f"{project_name}.types.Cow",
+ ]
+
+ created_enums = get_node_names(mock_ingestor, "Enum")
+
+ missing_enums = set(expected_enums) - created_enums
+ assert not missing_enums, f"Missing expected enums: {sorted(list(missing_enums))}"
+
+ expected_unions = [
f"{project_name}.types.FloatOrInt",
]
- created_classes = get_node_names(mock_ingestor, "Class")
+ created_unions = get_node_names(mock_ingestor, "Union")
- missing_classes = set(expected_classes) - created_classes
- assert not missing_classes, (
- f"Missing expected types: {sorted(list(missing_classes))}"
+ missing_unions = set(expected_unions) - created_unions
+ assert not missing_unions, (
+ f"Missing expected unions: {sorted(list(missing_unions))}"
)
expected_methods = [
@@ -495,6 +513,13 @@ def test_rust_traits_and_implementations(
f"{project_name}.traits.Drawable",
]
+ created_interfaces = get_node_names(mock_ingestor, "Interface")
+
+ missing_traits = set(expected_traits) - created_interfaces
+ assert not missing_traits, (
+ f"Missing expected traits: {sorted(list(missing_traits))}"
+ )
+
expected_structs = [
f"{project_name}.traits.Point",
f"{project_name}.traits.Circle",
@@ -502,10 +527,9 @@ def test_rust_traits_and_implementations(
created_classes = get_node_names(mock_ingestor, "Class")
- all_expected = expected_traits + expected_structs
- missing_classes = set(all_expected) - created_classes
- assert not missing_classes, (
- f"Missing expected traits/structs: {sorted(list(missing_classes))}"
+ missing_structs = set(expected_structs) - created_classes
+ assert not missing_structs, (
+ f"Missing expected structs: {sorted(list(missing_structs))}"
)
expected_methods = [
@@ -1059,19 +1083,27 @@ def test_rust_pattern_matching(
project_name = rust_project.name
- expected_types = [
- f"{project_name}.pattern_matching.Color",
- f"{project_name}.pattern_matching.Message",
+ expected_structs = [
f"{project_name}.pattern_matching.Point",
]
created_classes = get_node_names(mock_ingestor, "Class")
- found_types = set(expected_types) & created_classes
- assert len(found_types) >= 3, (
- f"Expected at least 3 types, found: {sorted(list(found_types))}"
+ missing_structs = set(expected_structs) - created_classes
+ assert not missing_structs, (
+ f"Missing expected structs: {sorted(list(missing_structs))}"
)
+ expected_enums = [
+ f"{project_name}.pattern_matching.Color",
+ f"{project_name}.pattern_matching.Message",
+ ]
+
+ created_enums = get_node_names(mock_ingestor, "Enum")
+
+ missing_enums = set(expected_enums) - created_enums
+ assert not missing_enums, f"Missing expected enums: {sorted(list(missing_enums))}"
+
expected_functions = [
f"{project_name}.pattern_matching.match_color",
f"{project_name}.pattern_matching.match_with_guards",
@@ -1535,19 +1567,25 @@ def test_rust_macros(
)
expected_structs = [
- f"{project_name}.macros.Person",
- f"{project_name}.macros.Point",
f"{project_name}.macros.MacroStruct",
- f"{project_name}.macros.MacroEnum",
]
created_classes = get_node_names(mock_ingestor, "Class")
- found_structs = set(expected_structs) & created_classes
- assert len(found_structs) >= 2, (
- f"Expected at least 2 macro structs, found: {sorted(list(found_structs))}"
+ missing_structs = set(expected_structs) - created_classes
+ assert not missing_structs, (
+ f"Missing expected structs: {sorted(list(missing_structs))}"
)
+ expected_enums = [
+ f"{project_name}.macros.MacroEnum",
+ ]
+
+ created_enums = get_node_names(mock_ingestor, "Enum")
+
+ missing_enums = set(expected_enums) - created_enums
+ assert not missing_enums, f"Missing expected enums: {sorted(list(missing_enums))}"
+
def test_rust_imports_and_use_statements(
rust_project: Path,
@@ -2050,9 +2088,9 @@ def test_rust_error_handling(
f"{project_name}.error_handling.CustomError",
]
- created_classes = get_node_names(mock_ingestor, "Class")
+ created_enums = get_node_names(mock_ingestor, "Enum")
- found_enums = set(expected_enums) & created_classes
+ found_enums = set(expected_enums) & created_enums
assert len(found_enums) >= 1, (
f"Expected at least 1 custom error enum, found: {sorted(list(found_enums))}"
)
@@ -2403,18 +2441,36 @@ def test_rust_comprehensive_integration(
project_name = rust_project.name
- expected_types = [
+ expected_structs = [
f"{project_name}.comprehensive.User",
- f"{project_name}.comprehensive.RepositoryError",
f"{project_name}.comprehensive.UserRepository",
- f"{project_name}.comprehensive.Repository",
]
created_classes = get_node_names(mock_ingestor, "Class")
- found_types = set(expected_types) & created_classes
- assert len(found_types) >= 3, (
- f"Expected at least 3 comprehensive types, found: {sorted(list(found_types))}"
+ missing_structs = set(expected_structs) - created_classes
+ assert not missing_structs, (
+ f"Missing expected structs: {sorted(list(missing_structs))}"
+ )
+
+ expected_enums = [
+ f"{project_name}.comprehensive.RepositoryError",
+ ]
+
+ created_enums = get_node_names(mock_ingestor, "Enum")
+
+ missing_enums = set(expected_enums) - created_enums
+ assert not missing_enums, f"Missing expected enums: {sorted(list(missing_enums))}"
+
+ expected_interfaces = [
+ f"{project_name}.comprehensive.Repository",
+ ]
+
+ created_interfaces = get_node_names(mock_ingestor, "Interface")
+
+ missing_interfaces = set(expected_interfaces) - created_interfaces
+ assert not missing_interfaces, (
+ f"Missing expected traits: {sorted(list(missing_interfaces))}"
)
diff --git a/codebase_rag/tests/test_rust_call_recall.py b/codebase_rag/tests/test_rust_call_recall.py
new file mode 100644
index 000000000..e0876373c
--- /dev/null
+++ b/codebase_rag/tests/test_rust_call_recall.py
@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag import constants as cs
+from codebase_rag.tests.conftest import run_updater
+
+
+def _calls(mock_ingestor: MagicMock) -> set[tuple[str, str]]:
+ out: set[tuple[str, str]] = set()
+ for c in mock_ingestor.ensure_relationship_batch.call_args_list:
+ if c.args[1] == cs.RelationshipType.CALLS:
+ out.add((c.args[0][2], c.args[2][2]))
+ return out
+
+
+class TestRustTurbofishCalls:
+ def test_turbofish_call_is_captured(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "tf.rs").write_text(
+ "fn generic_function(value: T) -> T { value }\n"
+ "\n"
+ "fn caller() {\n"
+ " let _ = generic_function::(10);\n"
+ "}\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="rust")
+ calls = _calls(mock_ingestor)
+
+ assert any(
+ caller.endswith(".caller") and callee.endswith(".generic_function")
+ for caller, callee in calls
+ ), f"turbofish call not captured; calls={sorted(calls)}"
+
+
+class TestRustMacroCalls:
+ def test_call_inside_macro_is_captured(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ (temp_repo / "mac.rs").write_text(
+ "fn describe(x: i32) -> i32 { x }\n"
+ "\n"
+ "fn caller() {\n"
+ ' println!("{}", describe(5));\n'
+ "}\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="rust")
+ calls = _calls(mock_ingestor)
+
+ assert any(
+ caller.endswith(".caller") and callee.endswith(".describe")
+ for caller, callee in calls
+ ), f"macro-internal call not captured; calls={sorted(calls)}"
+
+ def test_bare_identifier_in_macro_is_not_a_call(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) a plain value interpolated into a macro must not become a CALLS edge
+ (temp_repo / "mac2.rs").write_text(
+ "fn value() -> i32 { 1 }\n"
+ "\n"
+ "fn caller() {\n"
+ " let value = 5;\n"
+ ' println!("{}", value);\n'
+ "}\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="rust")
+ calls = _calls(mock_ingestor)
+
+ assert not any(
+ caller.endswith(".caller") and callee.endswith(".value")
+ for caller, callee in calls
+ ), f"bare identifier wrongly captured as call; calls={sorted(calls)}"
+
+ def test_struct_literal_in_macro_is_not_a_call(
+ self, temp_repo: Path, mock_ingestor: MagicMock
+ ) -> None:
+ # (H) `Widget { ... }` (token_tree starting with `{`) and `arr[..]` (starting
+ # (H) with `[`) inside a macro are not calls; only `name(...)` is.
+ (temp_repo / "mac3.rs").write_text(
+ "struct Widget { n: i32 }\n"
+ "fn helper() -> i32 { 1 }\n"
+ "\n"
+ "fn caller() {\n"
+ ' println!("{}", Widget { n: helper() }.n);\n'
+ "}\n",
+ encoding="utf-8",
+ )
+
+ run_updater(temp_repo, mock_ingestor, skip_if_missing="rust")
+ calls = _calls(mock_ingestor)
+
+ # (H) the real call inside the macro is still captured
+ assert any(
+ caller.endswith(".caller") and callee.endswith(".helper")
+ for caller, callee in calls
+ ), f"macro call not captured; calls={sorted(calls)}"
+ # (H) the struct literal `Widget { ... }` must not be a call
+ assert not any(
+ caller.endswith(".caller") and callee.endswith(".Widget")
+ for caller, callee in calls
+ ), f"struct literal wrongly captured as call; calls={sorted(calls)}"
diff --git a/codebase_rag/tests/test_rust_closure_containment_oracle.py b/codebase_rag/tests/test_rust_closure_containment_oracle.py
new file mode 100644
index 000000000..2e4666a33
--- /dev/null
+++ b/codebase_rag/tests/test_rust_closure_containment_oracle.py
@@ -0,0 +1,73 @@
+# (H) Covers Rust closure containment: a closure is DEFINEd by its nearest
+# (H) enclosing function-like scope (impl/trait method -> Method, free fn or outer
+# (H) closure -> Function). cgr routes closures through its free-function path; the
+# (H) syn oracle (evals/oracles/rs_oracle) emits the matching DEFINES via a stack
+# (H) of enclosing function-likes. Joined on (kind, file, line) endpoints.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_rust_graph
+from evals.oracles import run_rust_oracle, rust_available
+from evals.score import score_edge_types
+
+RS_SRC = """\
+pub struct Foo;
+
+impl Foo {
+ pub fn run(&self) -> i32 {
+ let c = |x: i32| x + 1;
+ let nested = || {
+ let inner = |z: i32| z * 2;
+ inner(5)
+ };
+ c(2) + nested()
+ }
+}
+
+pub trait Bar {
+ fn act(&self) -> i32 {
+ let t = |q: i32| q - 1;
+ t(9)
+ }
+}
+
+pub fn free() -> i32 {
+ let d = |y: i32| y + 2;
+ d(3)
+}
+"""
+
+
+def _require_rust() -> None:
+ if not rust_available():
+ pytest.skip("cargo toolchain not available")
+ if cs.SupportedLanguage.RUST not in load_parsers()[0]:
+ pytest.skip("rust parser not available")
+
+
+def test_cgr_matches_syn_oracle_on_closure_containment(tmp_path: Path) -> None:
+ _require_rust()
+ project = tmp_path / "rs_clo_edge"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_clo_edge"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(RS_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_rust_graph(project, project.name)
+ oracle = run_rust_oracle(project)
+
+ result = score_edge_types(cgr, oracle, ec.SCORED_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ row = by_label.get(cs.RelationshipType.DEFINES.value)
+ assert row is not None, (by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (row, result.diff)
+ # (H) The method-nested closures must contribute resolvable DEFINES edges,
+ # (H) not just the free-function one (the gap this fix closes).
+ assert row["tp"] >= 5, (row, result.diff)
diff --git a/codebase_rag/tests/test_rust_closure_method_defines.py b/codebase_rag/tests/test_rust_closure_method_defines.py
new file mode 100644
index 000000000..e46722b83
--- /dev/null
+++ b/codebase_rag/tests/test_rust_closure_method_defines.py
@@ -0,0 +1,84 @@
+# (H) Rust closures nested in an impl-method body must get a DEFINES edge from
+# (H) the enclosing METHOD, exactly as closures in free functions get one from
+# (H) the enclosing function. cgr used to derive the closure's DEFINES parent via
+# (H) the FQN scope walk, which could not read an impl block's target type, so the
+# (H) parent endpoint dropped the impl target (`lib.run` instead of `lib.Foo.run`)
+# (H) and never matched the real Method node, silently dropping the containment.
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.constants import KEY_QUALIFIED_NAME, NodeLabel, RelationshipType
+from codebase_rag.tests.conftest import (
+ create_and_run_updater,
+ get_nodes,
+ get_relationships,
+)
+
+_RS = """pub struct Foo;
+
+impl Foo {
+ pub fn run(&self) -> i32 {
+ let c = |x: i32| x + 1;
+ c(2)
+ }
+}
+
+pub fn free() -> i32 {
+ let d = |y: i32| y + 2;
+ d(3)
+}
+"""
+
+
+def _project(temp_repo: Path) -> Path:
+ project = temp_repo / "rs_clo"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_clo"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(encoding="utf-8", data=_RS)
+ return project
+
+
+def _defines_pairs(mock_ingestor: MagicMock) -> set[tuple[str, str, str]]:
+ # (H) (parent_label, parent_qn, child_qn) for DEFINES edges.
+ return {
+ (call[0][0][0], call[0][0][2], call[0][2][2])
+ for call in get_relationships(mock_ingestor, RelationshipType.DEFINES.value)
+ }
+
+
+def test_rust_closure_in_impl_method_defined_by_method(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(_project(temp_repo), mock_ingestor, skip_if_missing="rust")
+ file_mod = "rs_clo.src.lib"
+
+ method_qns = {
+ str(node[0][1].get(KEY_QUALIFIED_NAME))
+ for node in get_nodes(mock_ingestor, NodeLabel.METHOD)
+ }
+ assert f"{file_mod}.Foo.run" in method_qns, method_qns
+
+ function_qns = {
+ str(node[0][1].get(KEY_QUALIFIED_NAME))
+ for node in get_nodes(mock_ingestor, NodeLabel.FUNCTION)
+ }
+
+ pairs = _defines_pairs(mock_ingestor)
+ # (H) Every DEFINES edge's parent endpoint must resolve to a real node;
+ # (H) the method-closure edge used to point at the phantom `lib.run`.
+ method_defines = {
+ (parent_qn, child_qn)
+ for (parent_label, parent_qn, child_qn) in pairs
+ if parent_label == NodeLabel.METHOD.value
+ }
+ assert method_defines, pairs
+ closure_child = next(
+ child_qn
+ for (parent_qn, child_qn) in method_defines
+ if parent_qn == f"{file_mod}.Foo.run"
+ )
+ assert closure_child in function_qns, (closure_child, function_qns)
diff --git a/codebase_rag/tests/test_rust_containment_oracle.py b/codebase_rag/tests/test_rust_containment_oracle.py
new file mode 100644
index 000000000..9c0820b58
--- /dev/null
+++ b/codebase_rag/tests/test_rust_containment_oracle.py
@@ -0,0 +1,89 @@
+# (H) Covers Rust containment-edge validation: cgr's DEFINES (module -> item /
+# (H) nested module) and DEFINES_METHOD (struct/trait -> method) edges are graded
+# (H) against the independent syn oracle (evals/oracles/rs_oracle), joined on
+# (H) (kind, file, line) endpoints. Exercises an inherent impl, a trait method,
+# (H) and an impl inside a nested `mod` (cross-module type resolution).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_rust_graph
+from evals.oracles import run_rust_oracle, rust_available
+from evals.score import score_edge_types
+
+RS_SRC = """\
+pub trait Shape {
+ fn area(&self) -> f64 { 0.0 }
+}
+
+pub struct Point {
+ x: i32,
+}
+
+impl Point {
+ pub fn new() -> Point {
+ Point { x: 0 }
+ }
+}
+
+impl Shape for Point {
+ fn area(&self) -> f64 {
+ 1.0
+ }
+}
+
+pub fn free() -> i32 {
+ 1
+}
+
+pub mod inner {
+ pub struct Widget {
+ w: i32,
+ }
+
+ impl Widget {
+ pub fn build(&self) -> i32 {
+ self.w
+ }
+ }
+}
+"""
+
+
+def _require_rust() -> None:
+ if not rust_available():
+ pytest.skip("cargo toolchain not available")
+ if cs.SupportedLanguage.RUST not in load_parsers()[0]:
+ pytest.skip("rust parser not available")
+
+
+def test_cgr_matches_syn_oracle_on_containment_edges(tmp_path: Path) -> None:
+ _require_rust()
+ project = tmp_path / "rs_edge"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_edge"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(RS_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_rust_graph(project, project.name)
+ oracle = run_rust_oracle(project)
+
+ result = score_edge_types(cgr, oracle, ec.SCORED_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in (
+ cs.RelationshipType.DEFINES.value,
+ cs.RelationshipType.DEFINES_METHOD.value,
+ ):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (
+ label,
+ row,
+ result.diff,
+ )
diff --git a/codebase_rag/tests/test_rust_impl_primitive_target.py b/codebase_rag/tests/test_rust_impl_primitive_target.py
new file mode 100644
index 000000000..a6be79f62
--- /dev/null
+++ b/codebase_rag/tests/test_rust_impl_primitive_target.py
@@ -0,0 +1,44 @@
+# (H) Regression: methods in an `impl Trait for ` block (e.g.
+# (H) `impl From for u8`) must be captured. The impl target `u8` is a
+# (H) `primitive_type` node, which extract_impl_target did not recognise, so every
+# (H) method in such a block was silently dropped.
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.constants import KEY_QUALIFIED_NAME, NodeLabel
+from codebase_rag.tests.conftest import create_and_run_updater, get_nodes
+
+
+def test_rust_method_on_primitive_impl_target_is_captured(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "rs_prim"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_prim"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(
+ encoding="utf-8",
+ data="""pub enum Foo { A, B }
+
+impl From for u8 {
+ fn from(value: Foo) -> Self {
+ match value {
+ Foo::A => 0,
+ Foo::B => 1,
+ }
+ }
+}
+""",
+ )
+ create_and_run_updater(project, mock_ingestor, skip_if_missing="rust")
+
+ method_qns = {
+ str(node[0][1].get(KEY_QUALIFIED_NAME))
+ for node in get_nodes(mock_ingestor, NodeLabel.METHOD)
+ }
+ assert any(qn.endswith(".u8.from") for qn in method_qns), (
+ f"from() on impl-for-u8 not captured: {method_qns}"
+ )
diff --git a/codebase_rag/tests/test_rust_inheritance_edges.py b/codebase_rag/tests/test_rust_inheritance_edges.py
new file mode 100644
index 000000000..88bd34c58
--- /dev/null
+++ b/codebase_rag/tests/test_rust_inheritance_edges.py
@@ -0,0 +1,49 @@
+# (H) Rust inheritance was uncaptured: `impl Trait for Type` means Type
+# (H) IMPLEMENTS Trait, and a supertrait bound `trait Sub: Super` means Sub
+# (H) INHERITS Super. cgr emitted neither (impl blocks and trait bounds were
+# (H) never turned into inheritance edges).
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.constants import RelationshipType
+from codebase_rag.tests.conftest import create_and_run_updater, get_relationships
+
+_RS = """\
+pub trait Shape {}
+pub trait Drawable: Shape {}
+
+pub struct Circle;
+
+impl Shape for Circle {}
+impl Drawable for Circle {}
+"""
+
+
+def _pairs(mock_ingestor: MagicMock, rel: str) -> set[tuple[str, str]]:
+ return {
+ (call[0][0][2], call[0][2][2]) for call in get_relationships(mock_ingestor, rel)
+ }
+
+
+def test_rust_impl_and_supertrait_edges(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "rs_inh"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_inh"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(encoding="utf-8", data=_RS)
+ create_and_run_updater(project, mock_ingestor, skip_if_missing="rust")
+
+ inherits = _pairs(mock_ingestor, RelationshipType.INHERITS.value)
+ implements = _pairs(mock_ingestor, RelationshipType.IMPLEMENTS.value)
+ base = "rs_inh.src.lib"
+
+ # (H) impl Trait for Type -> Type IMPLEMENTS Trait.
+ assert (f"{base}.Circle", f"{base}.Shape") in implements, implements
+ assert (f"{base}.Circle", f"{base}.Drawable") in implements, implements
+ # (H) Supertrait bound -> Sub INHERITS Super.
+ assert (f"{base}.Drawable", f"{base}.Shape") in inherits, inherits
diff --git a/codebase_rag/tests/test_rust_inheritance_oracle.py b/codebase_rag/tests/test_rust_inheritance_oracle.py
new file mode 100644
index 000000000..3204a224e
--- /dev/null
+++ b/codebase_rag/tests/test_rust_inheritance_oracle.py
@@ -0,0 +1,59 @@
+# (H) Covers Rust inheritance-edge validation: cgr's INHERITS (supertrait bound)
+# (H) and IMPLEMENTS (`impl Trait for Type`) edges are graded against the syn
+# (H) oracle, by (source node, base SIMPLE NAME).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_rust_graph
+from evals.oracles import run_rust_oracle, rust_available
+from evals.score import score_name_edge_types
+
+RS_SRC = """\
+pub trait Shape {}
+pub trait Drawable: Shape {}
+
+pub struct Circle;
+
+impl Shape for Circle {}
+impl Drawable for Circle {}
+"""
+
+
+def _require_rust() -> None:
+ if not rust_available():
+ pytest.skip("cargo toolchain not available")
+ if cs.SupportedLanguage.RUST not in load_parsers()[0]:
+ pytest.skip("rust parser not available")
+
+
+def test_cgr_matches_syn_oracle_on_inheritance_edges(tmp_path: Path) -> None:
+ _require_rust()
+ project = tmp_path / "rs_inh_edge"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_inh_edge"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(RS_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_rust_graph(project, project.name)
+ oracle = run_rust_oracle(project)
+
+ result = score_name_edge_types(cgr, oracle, ec.INHERITANCE_NAME_EDGE_TYPES)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in (
+ cs.RelationshipType.INHERITS.value,
+ cs.RelationshipType.IMPLEMENTS.value,
+ ):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label, result.diff)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (
+ label,
+ row,
+ result.diff,
+ )
diff --git a/codebase_rag/tests/test_rust_nested_module_containment.py b/codebase_rag/tests/test_rust_nested_module_containment.py
new file mode 100644
index 000000000..7a924ed4c
--- /dev/null
+++ b/codebase_rag/tests/test_rust_nested_module_containment.py
@@ -0,0 +1,85 @@
+# (H) Rust nested-module containment. cgr qualifies items inside `mod inner`
+# (H) with the module path (proj...inner.X), but used to (a) DEFINE them from the
+# (H) FILE module while leaving the inner Module node an orphan, and (b) qualify
+# (H) impl methods inside the mod against the file module, producing a phantom
+# (H) DEFINES_METHOD parent that never matched the real type node. Containment
+# (H) must be module-nested: file module -> inner module -> its items, and an
+# (H) impl method binds to the type under its enclosing module path.
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.constants import KEY_QUALIFIED_NAME, NodeLabel, RelationshipType
+from codebase_rag.tests.conftest import (
+ create_and_run_updater,
+ get_nodes,
+ get_relationships,
+)
+
+_RS = """pub mod inner {
+ pub fn helper() -> i32 { 1 }
+
+ pub struct Widget { w: i32 }
+
+ impl Widget {
+ pub fn build(&self) -> i32 { self.w }
+ }
+}
+"""
+
+
+def _project(temp_repo: Path) -> Path:
+ project = temp_repo / "rs_mod"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_mod"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(encoding="utf-8", data=_RS)
+ return project
+
+
+def _defines_pairs(mock_ingestor: MagicMock) -> set[tuple[str, str, str]]:
+ # (H) (parent_label, parent_qn, child_qn) for DEFINES edges.
+ return {
+ (call[0][0][0], call[0][0][2], call[0][2][2])
+ for call in get_relationships(mock_ingestor, RelationshipType.DEFINES.value)
+ }
+
+
+def test_rust_nested_module_is_module_nested(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(_project(temp_repo), mock_ingestor, skip_if_missing="rust")
+ file_mod = "rs_mod.src.lib"
+ inner = f"{file_mod}.inner"
+ pairs = _defines_pairs(mock_ingestor)
+
+ # (H) file module DEFINES the inner module (no longer an orphan node).
+ assert (NodeLabel.MODULE.value, file_mod, inner) in pairs, pairs
+ # (H) inner module DEFINES its own items, not the file module.
+ assert (NodeLabel.MODULE.value, inner, f"{inner}.helper") in pairs, pairs
+ assert (NodeLabel.MODULE.value, inner, f"{inner}.Widget") in pairs, pairs
+
+
+def test_rust_impl_method_in_module_binds_to_nested_type(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ create_and_run_updater(_project(temp_repo), mock_ingestor, skip_if_missing="rust")
+ inner = "rs_mod.src.lib.inner"
+
+ method_qns = {
+ str(node[0][1].get(KEY_QUALIFIED_NAME))
+ for node in get_nodes(mock_ingestor, NodeLabel.METHOD)
+ }
+ assert f"{inner}.Widget.build" in method_qns, method_qns
+
+ defines_method = {
+ (call[0][0][2], call[0][2][2])
+ for call in get_relationships(
+ mock_ingestor, RelationshipType.DEFINES_METHOD.value
+ )
+ }
+ assert (f"{inner}.Widget", f"{inner}.Widget.build") in defines_method, (
+ defines_method
+ )
diff --git a/codebase_rag/tests/test_rust_node_type.py b/codebase_rag/tests/test_rust_node_type.py
new file mode 100644
index 000000000..edfa95e13
--- /dev/null
+++ b/codebase_rag/tests/test_rust_node_type.py
@@ -0,0 +1,99 @@
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parsers.class_ingest.node_type import determine_node_type
+from codebase_rag.tests.conftest import (
+ create_mock_node,
+ get_node_names,
+ run_updater,
+)
+from codebase_rag.types_defs import NodeType
+
+
+@pytest.mark.parametrize(
+ ("ts_node_type", "expected"),
+ [
+ (cs.TS_RS_ENUM_ITEM, NodeType.ENUM),
+ (cs.TS_RS_TRAIT_ITEM, NodeType.INTERFACE),
+ (cs.TS_RS_TYPE_ITEM, NodeType.TYPE),
+ (cs.TS_RS_UNION_ITEM, NodeType.UNION),
+ (cs.TS_RS_STRUCT_ITEM, NodeType.CLASS),
+ ],
+)
+def test_determine_node_type_rust(ts_node_type: str, expected: NodeType) -> None:
+ node = create_mock_node(ts_node_type)
+ result = determine_node_type(node, "Foo", "crate::Foo", cs.SupportedLanguage.RUST)
+ assert result == expected
+
+
+@pytest.fixture
+def rust_node_type_project(temp_repo: Path) -> Path:
+ project_path = temp_repo / "rust_node_type_test"
+ project_path.mkdir()
+ (project_path / "Cargo.toml").write_text(
+ encoding="utf-8",
+ data='[package]\nname = "rust_node_type_test"\nversion = "0.1.0"\n',
+ )
+ (project_path / "src").mkdir()
+ (project_path / "src" / "lib.rs").write_text(encoding="utf-8", data="")
+ (project_path / "types.rs").write_text(
+ encoding="utf-8",
+ data=(
+ "pub enum Color { Red, Green, Blue }\n"
+ "pub trait Drawable { fn draw(&self); }\n"
+ "pub type Pair = (i32, i32);\n"
+ "pub union IntOrFloat { i: i32, f: f32 }\n"
+ "pub struct Point { pub x: f64, pub y: f64 }\n"
+ ),
+ )
+ return project_path
+
+
+def test_rust_enum_label(
+ rust_node_type_project: Path, mock_ingestor: MagicMock
+) -> None:
+ run_updater(rust_node_type_project, mock_ingestor, skip_if_missing="rust")
+ enum_names = get_node_names(mock_ingestor, NodeType.ENUM)
+ assert len(enum_names) == 1
+ assert enum_names.pop().endswith(".Color")
+
+
+def test_rust_trait_label(
+ rust_node_type_project: Path, mock_ingestor: MagicMock
+) -> None:
+ run_updater(rust_node_type_project, mock_ingestor, skip_if_missing="rust")
+ interface_names = get_node_names(mock_ingestor, NodeType.INTERFACE)
+ assert len(interface_names) == 1
+ assert interface_names.pop().endswith(".Drawable")
+
+
+def test_rust_type_alias_label(
+ rust_node_type_project: Path, mock_ingestor: MagicMock
+) -> None:
+ run_updater(rust_node_type_project, mock_ingestor, skip_if_missing="rust")
+ type_names = get_node_names(mock_ingestor, NodeType.TYPE)
+ assert len(type_names) == 1
+ assert type_names.pop().endswith(".Pair")
+
+
+def test_rust_union_label(
+ rust_node_type_project: Path, mock_ingestor: MagicMock
+) -> None:
+ run_updater(rust_node_type_project, mock_ingestor, skip_if_missing="rust")
+ union_names = get_node_names(mock_ingestor, NodeType.UNION)
+ assert len(union_names) == 1
+ assert union_names.pop().endswith(".IntOrFloat")
+
+
+def test_rust_struct_label(
+ rust_node_type_project: Path, mock_ingestor: MagicMock
+) -> None:
+ run_updater(rust_node_type_project, mock_ingestor, skip_if_missing="rust")
+ class_names = get_node_names(mock_ingestor, NodeType.CLASS)
+ assert len(class_names) == 1
+ assert class_names.pop().endswith(".Point")
diff --git a/codebase_rag/tests/test_rust_span_oracle.py b/codebase_rag/tests/test_rust_span_oracle.py
new file mode 100644
index 000000000..5bd9abb53
--- /dev/null
+++ b/codebase_rag/tests/test_rust_span_oracle.py
@@ -0,0 +1,83 @@
+# (H) Covers Rust node SPAN (end_line) validation: cgr's end_line for each node is
+# (H) graded against the syn oracle (which emits the whole-node span end), joined
+# (H) on (kind, file, start) endpoints. Exercises doc comments, multi-line
+# (H) attributes, a multi-line signature, a where-clause, and a multi-line closure
+# (H) so the span is not trivially the start line.
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_rust_graph
+from evals.oracles import run_rust_oracle, rust_available
+from evals.score import score_span
+
+RS_SRC = """\
+/// A documented struct
+/// spanning several doc lines.
+#[derive(Debug, Clone)]
+pub struct Widget {
+ name: String,
+ size: u32,
+}
+
+impl Widget {
+ pub fn area(
+ &self,
+ scale: u32,
+ ) -> u32 {
+ self.size * scale
+ }
+}
+
+pub trait Drawable {
+ fn draw(&self) -> String {
+ String::from("x")
+ }
+}
+
+pub fn standalone()
+where
+ u32: Sized,
+{
+ let cb = |v: u32| {
+ v + 1
+ };
+ let _ = cb(2);
+}
+"""
+
+
+def _require_rust() -> None:
+ if not rust_available():
+ pytest.skip("cargo toolchain not available")
+ if cs.SupportedLanguage.RUST not in load_parsers()[0]:
+ pytest.skip("rust parser not available")
+
+
+def test_cgr_matches_syn_oracle_on_node_spans(tmp_path: Path) -> None:
+ _require_rust()
+ project = tmp_path / "rs_span"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_span"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(RS_SRC, encoding="utf-8")
+
+ cgr = extract_cgr_rust_graph(project, project.name)
+ oracle = run_rust_oracle(project)
+
+ result = score_span(cgr, oracle, ec.RS_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ aggregate = by_label.get(ec.AGGREGATE_LABEL)
+ assert aggregate is not None, (by_label, result.diff)
+ assert aggregate["precision"] == 1.0 and aggregate["recall"] == 1.0, (
+ aggregate,
+ result.diff,
+ )
+ # (H) Guard the sample actually exercises multi-line spans (else it is vacuous).
+ assert aggregate["tp"] >= 5, aggregate
diff --git a/codebase_rag/tests/test_rust_structure_oracle.py b/codebase_rag/tests/test_rust_structure_oracle.py
new file mode 100644
index 000000000..f9e9e9fa8
--- /dev/null
+++ b/codebase_rag/tests/test_rust_structure_oracle.py
@@ -0,0 +1,68 @@
+# (H) Covers the Rust structure oracle harness (evals/oracles/rs_oracle +
+# (H) evals/rust_l1.py): the syn-based oracle is authoritative ground truth, and
+# (H) cgr's captured Rust nodes are graded against it on (kind, file, start_line).
+from __future__ import annotations
+
+from pathlib import Path
+
+import pytest
+
+from codebase_rag import constants as cs
+from codebase_rag.parser_loader import load_parsers
+from evals import constants as ec
+from evals.cgr_graph import extract_cgr_rust_nodes
+from evals.oracles import run_rust_oracle, rust_available
+from evals.score import score_node_kinds
+from evals.types_defs import GraphData
+
+RS_SRC = """\
+pub struct Point { pub x: i32, pub y: i32 }
+pub enum Direction { North, South }
+pub trait Shape { fn area(&self) -> f64; }
+pub type Meters = f64;
+
+pub fn free_fn(a: i32) -> i32 { a + 1 }
+
+impl Point {
+ pub fn new(x: i32, y: i32) -> Self { Point { x, y } }
+}
+
+impl Shape for Point {
+ fn area(&self) -> f64 { 0.0 }
+}
+"""
+
+
+def _require_rust() -> None:
+ if not rust_available():
+ pytest.skip("cargo toolchain not available")
+ if cs.SupportedLanguage.RUST not in load_parsers()[0]:
+ pytest.skip("rust parser not available")
+
+
+def _project(tmp_path: Path) -> Path:
+ project = tmp_path / "rs_oracle_test"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_oracle_test"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(RS_SRC, encoding="utf-8")
+ return project
+
+
+def test_cgr_matches_syn_oracle_on_rust_structure(tmp_path: Path) -> None:
+ _require_rust()
+ project = _project(tmp_path)
+ cgr = GraphData(
+ nodes=extract_cgr_rust_nodes(project, project.name),
+ edges=set(),
+ name_edges=set(),
+ )
+ oracle = run_rust_oracle(project)
+
+ result = score_node_kinds(cgr, oracle, ec.RS_SCORED_NODE_KINDS)
+ by_label = {row["label"]: row for row in result.rows}
+ for label in ("Class", "Interface", "Enum", "Type", "Function", "Method"):
+ row = by_label.get(label)
+ assert row is not None, (label, by_label)
+ assert row["precision"] == 1.0 and row["recall"] == 1.0, (label, row)
diff --git a/codebase_rag/tests/test_rust_trait_method_containment.py b/codebase_rag/tests/test_rust_trait_method_containment.py
new file mode 100644
index 000000000..26db7c491
--- /dev/null
+++ b/codebase_rag/tests/test_rust_trait_method_containment.py
@@ -0,0 +1,43 @@
+# (H) Regression: a DEFINES_METHOD relationship is matched in the graph by the
+# (H) parent's LABEL and qualified_name, so a method on a non-Class container
+# (H) (a Rust trait -> Interface node) must be emitted with the parent's real
+# (H) label. It was hardcoded to Class, so MATCH (a:Class {qn: trait}) found
+# (H) nothing and the trait -> method containment edge was silently dropped.
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+from codebase_rag.constants import NodeLabel, RelationshipType
+from codebase_rag.tests.conftest import create_and_run_updater, get_relationships
+
+
+def test_rust_trait_method_defined_by_interface_node(
+ temp_repo: Path, mock_ingestor: MagicMock
+) -> None:
+ project = temp_repo / "rs_trait"
+ (project / "src").mkdir(parents=True)
+ (project / "Cargo.toml").write_text(
+ encoding="utf-8", data='[package]\nname = "rs_trait"\nversion = "0.1.0"\n'
+ )
+ (project / "src" / "lib.rs").write_text(
+ encoding="utf-8",
+ data="""pub trait Shape {
+ fn area(&self) -> f64 { 0.0 }
+}
+""",
+ )
+ create_and_run_updater(project, mock_ingestor, skip_if_missing="rust")
+
+ defines_method = get_relationships(
+ mock_ingestor, RelationshipType.DEFINES_METHOD.value
+ )
+ # (H) (parent_label, parent_qn) pairs for the trait's method.
+ parents = {
+ (call[0][0][0], call[0][0][2])
+ for call in defines_method
+ if str(call[0][2][2]).endswith(".Shape.area")
+ }
+ assert (NodeLabel.INTERFACE.value, "rs_trait.src.lib.Shape") in parents, parents
+ # (H) The wrong Class-labelled parent must not be emitted.
+ assert (NodeLabel.CLASS.value, "rs_trait.src.lib.Shape") not in parents, parents
diff --git a/codebase_rag/tests/test_shell_command.py b/codebase_rag/tests/test_shell_command.py
index f745b2e30..cf57396d1 100644
--- a/codebase_rag/tests/test_shell_command.py
+++ b/codebase_rag/tests/test_shell_command.py
@@ -1,5 +1,6 @@
from __future__ import annotations
+import sys
from pathlib import Path
from unittest.mock import MagicMock
@@ -274,6 +275,64 @@ def test_empty_segment(self) -> None:
available = ", ".join(sorted(settings.SHELL_COMMAND_ALLOWLIST))
assert _validate_segment("", available) is None
+ def test_bypass_allowlist_skips_allowlist_error(self) -> None:
+ available = ", ".join(sorted(settings.SHELL_COMMAND_ALLOWLIST))
+ assert (
+ _validate_segment(
+ "curl http://example.com", available, bypass_allowlist=True
+ )
+ is None
+ )
+
+ def test_bypass_allowlist_still_blocks_dangerous_rm(self) -> None:
+ available = ", ".join(sorted(settings.SHELL_COMMAND_ALLOWLIST))
+ error = _validate_segment("rm -rf /", available, bypass_allowlist=True)
+ assert error is not None
+ assert "dangerous" in error.lower()
+
+
+class TestYoloMode:
+ async def test_yolo_skips_approval_for_write_command(
+ self, temp_project_root: Path
+ ) -> None:
+ test_file = temp_project_root / "yolo_target.txt"
+ test_file.write_text("bye", encoding="utf-8")
+ commander = ShellCommander(
+ str(temp_project_root), timeout=5, is_yolo=lambda: True
+ )
+ tool = create_shell_command_tool(commander)
+ mock_ctx = MagicMock()
+ mock_ctx.tool_call_approved = False
+ result = await tool.function(mock_ctx, "rm yolo_target.txt")
+ assert result.return_code == 0
+ assert not test_file.exists()
+
+ async def test_yolo_runs_non_allowlist_command(
+ self, temp_project_root: Path
+ ) -> None:
+ commander = ShellCommander(
+ str(temp_project_root), timeout=5, is_yolo=lambda: True
+ )
+ tool = create_shell_command_tool(commander)
+ mock_ctx = MagicMock()
+ mock_ctx.tool_call_approved = False
+ assert "printf" not in settings.SHELL_COMMAND_ALLOWLIST
+ result = await tool.function(mock_ctx, "printf hello")
+ assert "not in the allowlist" not in result.stderr
+
+ async def test_yolo_still_blocks_dangerous_rm_rf(
+ self, temp_project_root: Path
+ ) -> None:
+ commander = ShellCommander(
+ str(temp_project_root), timeout=5, is_yolo=lambda: True
+ )
+ tool = create_shell_command_tool(commander)
+ mock_ctx = MagicMock()
+ mock_ctx.tool_call_approved = False
+ result = await tool.function(mock_ctx, "rm -rf /")
+ assert result.return_code != 0
+ assert "dangerous" in result.stderr.lower()
+
class TestHasRedirectOperators:
def test_output_redirect(self) -> None:
@@ -386,6 +445,9 @@ async def test_simple_pipe(
assert result.return_code == 0
assert "5" in result.stdout
+ @pytest.mark.skipif(
+ sys.platform == "win32", reason="Unix find not available on Windows"
+ )
async def test_find_with_wc(
self, shell_commander: ShellCommander, temp_project_root: Path
) -> None:
@@ -398,6 +460,10 @@ async def test_find_with_wc(
async def test_rg_in_pipeline(
self, shell_commander: ShellCommander, temp_project_root: Path
) -> None:
+ import shutil
+
+ if not shutil.which("rg"):
+ pytest.skip("rg (ripgrep) not installed")
(temp_project_root / "data.txt").write_text("foo\nbar\nbaz\n", encoding="utf-8")
result = await shell_commander.execute("cat data.txt | rg bar")
assert result.return_code == 0
@@ -630,11 +696,11 @@ def test_path_outside_project(self, tmp_path: Path) -> None:
["rm", "-rf", "../other"], project_root
)
assert is_dangerous
- assert "outside project" in reason
+ assert "outside project" in reason or "system directory" in reason
def test_safe_path_inside_project(self, tmp_path: Path) -> None:
- project_root = tmp_path / "project"
- project_root.mkdir()
+ project_root = (tmp_path / "project").resolve()
+ project_root.mkdir(exist_ok=True)
is_dangerous, _ = _is_dangerous_rm_path(
["rm", "-rf", "subdir/file.txt"], project_root
)
@@ -741,7 +807,8 @@ async def test_rm_outside_project_blocked(
) -> None:
result = await shell_commander.execute("rm ../outside_project")
assert result.return_code == -1
- assert "outside project" in result.stderr.lower()
+ stderr_lower = result.stderr.lower()
+ assert "outside project" in stderr_lower or "system directory" in stderr_lower
class TestAwkSedXargsPatterns:
diff --git a/codebase_rag/tests/test_sibling_mixin_resolution.py b/codebase_rag/tests/test_sibling_mixin_resolution.py
new file mode 100644
index 000000000..48bb15156
--- /dev/null
+++ b/codebase_rag/tests/test_sibling_mixin_resolution.py
@@ -0,0 +1,97 @@
+# (H) L3 finding from the evals/ harness: PythonAstAnalyzerMixin._traverse_single_pass
+# (H) calls self._infer_instance_variable_types_from_assignments(...), a method defined
+# (H) on the sibling PythonVariableAnalyzerMixin. Neither is the other's base; both are
+# (H) combined into the concrete PythonTypeInferenceEngine. A same-named stub in another
+# (H) class makes the bare-name trie fallback ambiguous, so resolution must go through
+# (H) the concrete subclass's MRO to land on the real sibling method.
+from __future__ import annotations
+
+from pathlib import Path
+
+from codebase_rag import constants as cs
+from codebase_rag.graph_updater import GraphUpdater
+from codebase_rag.parser_loader import load_parsers
+from codebase_rag.types_defs import PropertyDict, PropertyValue, ResultRow
+
+PROJECT = "proj"
+
+FILES = {
+ "pkg/__init__.py": "",
+ # (H) A decoy class declaring the same method name (mirrors a TYPE_CHECKING stub)
+ # (H) so the trie fallback alone cannot pick the right target.
+ "pkg/decoy.py": ("class Deps:\n def infer_vars(self):\n return None\n"),
+ "pkg/mixin_a.py": (
+ "class AMixin:\n def traverse(self):\n return self.infer_vars()\n"
+ ),
+ "pkg/mixin_b.py": ("class BMixin:\n def infer_vars(self):\n return {}\n"),
+ "pkg/engine.py": (
+ "from .mixin_a import AMixin\n"
+ "from .mixin_b import BMixin\n\n\n"
+ "class Engine(AMixin, BMixin):\n"
+ " def other(self):\n"
+ " return None\n"
+ ),
+}
+
+
+class _Capture:
+ def __init__(self) -> None:
+ self.rels: list[tuple[PropertyValue, str, PropertyValue]] = []
+
+ def ensure_node_batch(self, label: str, properties: PropertyDict) -> None:
+ return None
+
+ def ensure_relationship_batch(
+ self,
+ from_spec: tuple[str, str, PropertyValue],
+ rel_type: str,
+ to_spec: tuple[str, str, PropertyValue],
+ properties: PropertyDict | None = None,
+ ) -> None:
+ self.rels.append((from_spec[2], str(rel_type), to_spec[2]))
+
+ def flush_all(self) -> None:
+ return None
+
+ def fetch_all(
+ self, query: str, params: PropertyDict | None = None
+ ) -> list[ResultRow]:
+ return []
+
+ def execute_write(self, query: str, params: PropertyDict | None = None) -> None:
+ return None
+
+
+def _calls(tmp_path: Path) -> set[tuple[PropertyValue, PropertyValue]]:
+ for rel, content in FILES.items():
+ p = tmp_path / rel
+ p.parent.mkdir(parents=True, exist_ok=True)
+ p.write_text(content)
+ parsers, queries = load_parsers()
+ cap = _Capture()
+ GraphUpdater(
+ ingestor=cap,
+ repo_path=tmp_path,
+ parsers=parsers,
+ queries=queries,
+ project_name=PROJECT,
+ ).run(force=True)
+ return {
+ (frm, to) for (frm, rel, to) in cap.rels if rel == cs.RelationshipType.CALLS
+ }
+
+
+class TestSiblingMixinResolution:
+ def test_self_call_resolves_to_sibling_mixin_method(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.mixin_a.AMixin.traverse",
+ "proj.pkg.mixin_b.BMixin.infer_vars",
+ ) in calls, calls
+
+ def test_does_not_resolve_to_decoy_class(self, tmp_path: Path) -> None:
+ calls = _calls(tmp_path)
+ assert (
+ "proj.pkg.mixin_a.AMixin.traverse",
+ "proj.pkg.decoy.Deps.infer_vars",
+ ) not in calls, calls
diff --git a/codebase_rag/tests/test_single_file_repo_path.py b/codebase_rag/tests/test_single_file_repo_path.py
new file mode 100644
index 000000000..71d4a28a7
--- /dev/null
+++ b/codebase_rag/tests/test_single_file_repo_path.py
@@ -0,0 +1,138 @@
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from codebase_rag.tests.conftest import (
+ get_node_names,
+ get_relationships,
+ run_updater,
+)
+
+
+@pytest.fixture
+def cpp_single_file(temp_repo: Path) -> Path:
+ test_file = temp_repo / "cmGlobalFastbuildGenerator.cxx"
+ test_file.write_text(
+ encoding="utf-8",
+ data="""
+#include 
