nprasad2077/codebase-memory-mcp
1
0 Fork 0
mirror of https://github.com/DeusData/codebase-memory-mcp.git synced 2026-11-04 10:48:20 +00:00
Code Issues Packages Projects Releases Wiki Activity

Merge branch 'main' into fix/hermes-remover-empty-hooks

Browse Source
This commit is contained in:
Martin Vogel authored and GitHub committed 2026-11-03 03:46:36 +01:00
2 parents e8f0f4a289 5689ea54ce
commit d681c37d37
61 files changed
+8803 -105
Download Patch File Download Diff File Expand all files Collapse all files

No files matched your search

.github/workflows/_build.yml
+13 -13
View File
@@ -108,7 +108,7 @@ jobs:
release-candidates/${{ matrix.goos }}-${{ matrix.goarch }}/unstripped/*
release-candidates/${{ matrix.goos }}-${{ matrix.goarch }}/THIRD_PARTY_NOTICES.md
- uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
- uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: release-candidates-${{ matrix.goos }}-${{ matrix.goarch }}
path: release-candidates/${{ matrix.goos }}-${{ matrix.goarch }}
@@ -166,7 +166,7 @@ jobs:
release-candidates/windows-amd64/unstripped/*
release-candidates/windows-amd64/THIRD_PARTY_NOTICES.md
- uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
- uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: release-candidates-windows-amd64
path: release-candidates/windows-amd64
@@ -228,7 +228,7 @@ jobs:
release-candidates/windows-arm64/unstripped/*
release-candidates/windows-arm64/THIRD_PARTY_NOTICES.md
- uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
- uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: release-candidates-windows-arm64
path: release-candidates/windows-arm64
@@ -292,7 +292,7 @@ jobs:
release-candidates/linux-${{ matrix.arch }}-portable/unstripped/*
release-candidates/linux-${{ matrix.arch }}-portable/THIRD_PARTY_NOTICES.md
- uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
- uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: release-candidates-linux-${{ matrix.arch }}-portable
path: release-candidates/linux-${{ matrix.arch }}-portable
@@ -446,7 +446,7 @@ jobs:
- name: Preserve candidate selection evidence
if: ${{ always() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: release-selection-evidence
path: selection-evidence
@@ -455,56 +455,56 @@ jobs:
# Keep the established artifact names so the reusable smoke workflow and
# all callers consume only the selected, byte-verified containers.
- name: Upload linux-amd64 containers
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: binaries-linux-amd64
path: release-containers/linux-amd64/*
if-no-files-found: error
- name: Upload linux-arm64 containers
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: binaries-linux-arm64
path: release-containers/linux-arm64/*
if-no-files-found: error
- name: Upload linux-amd64-portable containers
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: binaries-linux-amd64-portable
path: release-containers/linux-amd64-portable/*
if-no-files-found: error
- name: Upload linux-arm64-portable containers
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: binaries-linux-arm64-portable
path: release-containers/linux-arm64-portable/*
if-no-files-found: error
- name: Upload darwin-amd64 containers
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: binaries-darwin-amd64
path: release-containers/darwin-amd64/*
if-no-files-found: error
- name: Upload darwin-arm64 containers
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: binaries-darwin-arm64
path: release-containers/darwin-arm64/*
if-no-files-found: error
- name: Upload windows-amd64 containers
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: binaries-windows-amd64
path: release-containers/windows-amd64/*
if-no-files-found: error
- name: Upload windows-arm64 containers
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: binaries-windows-arm64
path: release-containers/windows-arm64/*
.github/workflows/_memwaste.yml
+5 -5
View File
@@ -52,7 +52,7 @@ jobs:
run: python3 scripts/memwaste-ratchet.py --out "$RUNNER_TEMP/memwaste-event" --venue ${{ inputs.mode }}-linux
- name: Upload report
if: ${{ always() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: memwaste-event-linux-${{ inputs.mode }}
path: |
@@ -82,7 +82,7 @@ jobs:
--out "$RUNNER_TEMP/memwaste-scaling" | tee "$RUNNER_TEMP/memwaste-scaling/report.txt"
- name: Upload report
if: ${{ always() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: memwaste-scaling-linux-${{ inputs.mode }}
path: ${{ runner.temp }}/memwaste-scaling/report.txt
@@ -108,7 +108,7 @@ jobs:
--out "$RUNNER_TEMP/memwaste-access" | tee "$RUNNER_TEMP/memwaste-access/report.txt"
- name: Upload report
if: ${{ always() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: memwaste-access-linux-${{ inputs.mode }}
path: |
@@ -135,7 +135,7 @@ jobs:
run: python3 scripts/memwaste-ratchet.py --out "$RUNNER_TEMP/memwaste-event" --venue full-macos
- name: Upload report
if: ${{ always() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: memwaste-event-macos-${{ inputs.mode }}
path: |
@@ -177,7 +177,7 @@ jobs:
run: python3 scripts/memwaste-ratchet.py --out "$(cygpath -u "$RUNNER_TEMP")/memwaste-event" --venue full-windows
- name: Upload report
if: ${{ always() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: memwaste-event-windows-${{ inputs.mode }}
path: |
.github/workflows/_soak.yml
+10 -10
View File
@@ -98,14 +98,14 @@ jobs:
scripts/soak-legs.sh --legs "${{ inputs.legs }}" "$binary" ${{ inputs.duration_minutes }}
- name: Upload metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-quick-${{ matrix.goos }}-${{ matrix.goarch }}
path: soak-results/
retention-days: 14
- name: Upload query-leak metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-query-leak-${{ matrix.goos }}-${{ matrix.goarch }}
path: soak-results-query-leak/
@@ -175,14 +175,14 @@ jobs:
scripts/soak-legs.sh --legs "${{ inputs.legs }}" "$binary" ${{ inputs.duration_minutes }}
- name: Upload metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-quick-windows-amd64
path: soak-results/
retention-days: 14
- name: Upload query-leak metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-query-leak-windows-amd64
path: soak-results-query-leak/
@@ -253,14 +253,14 @@ jobs:
scripts/soak-legs.sh --legs "${{ inputs.legs }}" "$binary" ${{ inputs.duration_minutes }}
- name: Upload metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-quick-windows-arm64
path: soak-results/
retention-days: 14
- name: Upload query-leak metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-query-leak-windows-arm64
path: soak-results-query-leak/
@@ -305,14 +305,14 @@ jobs:
${{ inputs.duration_minutes }}
- name: Upload metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-quick-linux-${{ matrix.arch }}-portable
path: soak-results/
retention-days: 14
- name: Upload query-leak metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-query-leak-linux-${{ matrix.arch }}-portable
path: soak-results-query-leak/
@@ -373,7 +373,7 @@ jobs:
run: scripts/soak-legs.sh --legs quick build/c/codebase-memory-mcp 15
- name: Upload metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-asan-${{ matrix.goos }}-${{ matrix.goarch }}
path: soak-results/
@@ -413,7 +413,7 @@ jobs:
run: scripts/soak-legs.sh --legs quick build/c/codebase-memory-mcp 15
- name: Upload metrics
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: soak-asan-windows-amd64
path: soak-results/
.github/workflows/_test.yml
+7 -7
View File
@@ -253,7 +253,7 @@ jobs:
# too keeps red iterations warm.
- name: Shard manifest (completeness proof)
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: shard-manifest-${{ matrix.os }}-${{ matrix.cc }}-${{ strategy.job-index }}
path: build/c/test-logs/shard-manifest.txt
@@ -274,7 +274,7 @@ jobs:
# directory, and a second error would only bury the first.
- name: Failing suite logs
if: failure()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: suite-logs-${{ matrix.os }}-${{ matrix.cc }}-${{ strategy.job-index }}
path: build/c/test-logs/failed/
@@ -318,7 +318,7 @@ jobs:
with:
node-version: "22"
- uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
- uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
with:
python-version: "3.12"
@@ -406,7 +406,7 @@ jobs:
# not end green, only when the job failed.
- name: Failing suite logs
if: failure()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: suite-logs-diag
path: build/c/test-logs/failed/
@@ -504,7 +504,7 @@ jobs:
# not end green, only when the job failed.
- name: Failing suite logs
if: failure()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: suite-logs-lsan-macos
path: build/c/test-logs/failed/
@@ -669,7 +669,7 @@ jobs:
- name: Shard manifest (completeness proof)
if: always()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: shard-manifest-${{ matrix.os }}-${{ matrix.msystem }}-${{ strategy.job-index }}
path: build/c/test-logs/shard-manifest.txt
@@ -684,7 +684,7 @@ jobs:
# not end green, only when the job failed.
- name: Failing suite logs
if: failure()
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: suite-logs-${{ matrix.os }}-${{ matrix.msystem }}-${{ strategy.job-index }}
path: build/c/test-logs/failed/
.github/workflows/dry-run.yml
+1 -1
View File
@@ -148,7 +148,7 @@ jobs:
run: scripts/fuzz.sh all --runs 20000 --seed 1
- name: Upload reproducers
if: ${{ failure() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: fuzz-artifacts
path: build/fuzz/artifacts-*/
.github/workflows/nightly-soak.yml
+1 -1
View File
@@ -51,7 +51,7 @@ jobs:
run: scripts/fuzz.sh all --max-total-time 1800 --seed 0
- name: Upload reproducers
if: ${{ failure() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: fuzz-artifacts-nightly
path: build/fuzz/artifacts-*/
.github/workflows/pr.yml
+3 -3
View File
@@ -78,7 +78,7 @@ jobs:
run: scripts/ci/test-impact-select.sh --binary build/c/codebase-memory-mcp --out "$RUNNER_TEMP/test-impact" --gate "$RUNNER_TEMP/test-selection"
- name: Upload the selection
if: ${{ steps.select.outputs.selection == 'narrowed' }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: test-selection
path: ${{ runner.temp }}/test-selection
@@ -88,7 +88,7 @@ jobs:
# for the vetoes, never read by a test leg.
- name: Upload the vetoed selection
if: ${{ !cancelled() && steps.select.outcome != 'skipped' }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: test-selection-vetoed
path: ${{ runner.temp }}/test-impact/selection-vetoed.json
@@ -342,7 +342,7 @@ jobs:
run: scripts/ci/test-impact-select.sh --binary build/c/codebase-memory-mcp --out "$RUNNER_TEMP/test-impact"
- name: Upload the prediction
if: ${{ always() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: test-impact-prediction
path: |
.github/workflows/release.yml
+3 -3
View File
@@ -236,7 +236,7 @@ jobs:
# same-run workflow artifact, not a draft-release download, so that
# job keeps contents: read and no gh dependency.
- name: Preserve checksums for the registry job
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: release-checksums
path: checksums.txt
@@ -429,7 +429,7 @@ jobs:
- name: Preserve extracted-object VirusTotal evidence
if: ${{ always() }}
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: virustotal-evidence-release-${{ github.run_id }}
path: |
@@ -535,7 +535,7 @@ jobs:
# ── PyPI ─────────────────────────────────────────────────
- name: Setup Python
uses: actions/setup-python@5fda3b95a4ea91299a34e894583c3862153e4b97 # v7.0.0
uses: actions/setup-python@6d4fd22b20465ccc0f7354476588e8df7c9ca0e0 # v7.1.0
with:
python-version: '3.12'
.github/workflows/test-impact-artifact.yml
+1 -1
View File
@@ -79,7 +79,7 @@ jobs:
--out "$RUNNER_TEMP/bundle" --mode "$mode" --before "$before"
- name: Upload the bundle
uses: actions/upload-artifact@043fb46d1a93c77aae656e7c1c64a875d1fc6a0a # v7.0.1
uses: actions/upload-artifact@cf430e030ddbb5b0abf93d22962f4752f3646cd9 # v7.0.2
with:
name: test-impact-${{ github.sha }}
path: ${{ runner.temp }}/bundle
Makefile.cbm
+3 -1
View File
@@ -415,6 +415,7 @@ EXTRACTION_SRCS = \
$(CBM_DIR)/diagram.c \
$(CBM_DIR)/route_path.c \
$(CBM_DIR)/openapi.c \
$(CBM_DIR)/extract_nextjs.c \
$(CBM_DIR)/sql_values.c \
$(CBM_DIR)/helpers.c \
$(CBM_DIR)/cpp_branch_views.c \
@@ -886,6 +887,7 @@ TEST_CS_LSP_SRCS = tests/test_cs_lsp.c
TEST_CS_LSP_BENCH_SRCS = tests/test_cs_lsp_bench.c
TEST_PERL_LSP_SRCS = tests/test_perl_lsp.c
TEST_RUBY_LSP_SRCS = tests/test_ruby_lsp.c
TEST_SCOPE_SRCS = tests/test_scope.c
@@ -1009,7 +1011,7 @@ TEST_REPRO_SRCS = \
tests/repro/repro_lsp_java_cs.c \
tests/repro/repro_lsp_kt_php_rust.c
ALL_TEST_SRCS =$(TEST_FOUNDATION_SRCS) $(TEST_EXTRACTION_SRCS) $(TEST_STORE_SRCS) $(TEST_CYPHER_SRCS) $(TEST_MCP_SRCS) $(TEST_DAEMON_SRCS) $(TEST_DISCOVER_SRCS) $(TEST_GRAPH_BUFFER_SRCS) $(TEST_PIPELINE_SRCS) $(TEST_WATCHER_SRCS) $(TEST_LZ4_SRCS) $(TEST_ZSTD_SRCS) $(TEST_ARTIFACT_SRCS) $(TEST_SQLITE_WRITER_SRCS) $(TEST_GO_LSP_SRCS) $(TEST_C_LSP_SRCS) $(TEST_PHP_LSP_SRCS) $(TEST_CS_LSP_SRCS) $(TEST_CS_LSP_BENCH_SRCS) $(TEST_PERL_LSP_SRCS) $(TEST_SCOPE_SRCS) $(TEST_TYPE_REP_SRCS) $(TEST_PY_LSP_SRCS) $(TEST_PY_LSP_BENCH_SRCS) $(TEST_PY_LSP_STRESS_SRCS) $(TEST_PY_LSP_SCALE_SRCS) $(TEST_TS_LSP_SRCS) $(TEST_JAVA_LSP_SRCS) $(TEST_KOTLIN_LSP_SRCS) $(TEST_RUST_LSP_SRCS) $(TEST_TRACES_SRCS) $(TEST_CLI_SRCS) $(TEST_MEM_SRCS) $(TEST_UI_SRCS) $(TEST_HTTPD_SRCS) $(TEST_SECURITY_SRCS) $(TEST_YAML_SRCS) $(TEST_SEMANTIC_SRCS) $(TEST_AST_PROFILE_SRCS) $(TEST_SLAB_ALLOC_SRCS) $(TEST_SIMHASH_SRCS) $(TEST_STACK_OVERFLOW_SRCS) $(TEST_INTEGRATION_SRCS)
ALL_TEST_SRCS =$(TEST_FOUNDATION_SRCS) $(TEST_EXTRACTION_SRCS) $(TEST_STORE_SRCS) $(TEST_CYPHER_SRCS) $(TEST_MCP_SRCS) $(TEST_DAEMON_SRCS) $(TEST_DISCOVER_SRCS) $(TEST_GRAPH_BUFFER_SRCS) $(TEST_PIPELINE_SRCS) $(TEST_WATCHER_SRCS) $(TEST_LZ4_SRCS) $(TEST_ZSTD_SRCS) $(TEST_ARTIFACT_SRCS) $(TEST_SQLITE_WRITER_SRCS) $(TEST_GO_LSP_SRCS) $(TEST_C_LSP_SRCS) $(TEST_PHP_LSP_SRCS) $(TEST_CS_LSP_SRCS) $(TEST_CS_LSP_BENCH_SRCS) $(TEST_PERL_LSP_SRCS) $(TEST_RUBY_LSP_SRCS) $(TEST_SCOPE_SRCS) $(TEST_TYPE_REP_SRCS) $(TEST_PY_LSP_SRCS) $(TEST_PY_LSP_BENCH_SRCS) $(TEST_PY_LSP_STRESS_SRCS) $(TEST_PY_LSP_SCALE_SRCS) $(TEST_TS_LSP_SRCS) $(TEST_JAVA_LSP_SRCS) $(TEST_KOTLIN_LSP_SRCS) $(TEST_RUST_LSP_SRCS) $(TEST_TRACES_SRCS) $(TEST_CLI_SRCS) $(TEST_MEM_SRCS) $(TEST_UI_SRCS) $(TEST_HTTPD_SRCS) $(TEST_SECURITY_SRCS) $(TEST_YAML_SRCS) $(TEST_SEMANTIC_SRCS) $(TEST_AST_PROFILE_SRCS) $(TEST_SLAB_ALLOC_SRCS) $(TEST_SIMHASH_SRCS) $(TEST_STACK_OVERFLOW_SRCS) $(TEST_INTEGRATION_SRCS)
# ── Build directories ────────────────────────────────────────────
README.md
+3
View File
@@ -263,6 +263,8 @@ To turn the watcher off entirely, set `config set watcher_enabled false` (defaul
The watcher follows **git** projects only by default: a project indexed from a directory that is not a git repository is not watched and stays at its last index until you run `index_repository` again. To have such roots polled too, set `config set watch_non_git true` (default `false`, read when the daemon starts): they are then checked on the same cadence with a file-tree scan that uses the indexer's own ignore rules.
Linked git worktrees are indexed as their own projects by default. Set `config set ignore_worktrees true` to skip them on the automatic paths — useful when short-lived `git worktree add` checkouts would otherwise each leave behind a permanent index of the same repository. An explicit `index_repository` call on a worktree is then refused unless you pass `index_worktree=true`. See [docs/CONFIGURATION.md](docs/CONFIGURATION.md#ignore_worktrees).
### Keeping Up to Date
**Updates run from the install script on every platform, not from inside the running binary.** `codebase-memory-mcp update` validates your flags and then prints the exact command to run:
@@ -1016,6 +1018,7 @@ codebase-memory-mcp config list # show all settings
codebase-memory-mcp config set auto_index true # auto-index on session start
codebase-memory-mcp config set auto_index_limit 50000 # max files for auto-index
codebase-memory-mcp config set auto_watch false # remove/disable all background watches (default: true)
codebase-memory-mcp config set ignore_worktrees true # skip linked git worktrees when auto-indexing (default: false)
codebase-memory-mcp config set doc_candidates false # skip doc<->code candidate scoring on huge repos (default: auto = on for full, off for moderate/fast)
codebase-memory-mcp config set watcher_enabled false # stop the watcher thread entirely (default: true)
codebase-memory-mcp config set watch_non_git true # also poll non-git project roots (default: false)
docs/CONFIGURATION.md
+39
View File
@@ -87,6 +87,7 @@ Current keys:
|---|---|---|
| `auto_index` | `false` | Automatically index new projects when an MCP session starts. |
| `auto_index_limit` | `50000` | Maximum file count allowed for automatic indexing of a new project. |
| `ignore_worktrees` | `false` | Skip linked git worktrees (`git worktree add`) when indexing automatically. |
| `auto_watch` | `true` | Global switch for MCP session watch registration. On the next refresh or registration request, `true` allows session roots and successful `index_repository` targets to be watched; `false` removes all watches. The background watcher can still run with no registered projects. |
| `doc_candidates` | `auto` | Score documentation sections against code to store doc↔code candidates (the possible targets of a section, and the sections that may describe a function or file, each with a judged probability). Unset (`auto`), the index mode decides: on for `full` indexes (the default mode), off for `moderate` and `fast`. Set `true` or `false` to choose for every mode; `config reset doc_candidates` returns to `auto`. The scoring grows with sections × functions: under a second up to ~100k functions, ~15 s at ~400k, ~3 minutes on the Linux kernel. Off stores no candidates and leaves the rest of the graph unchanged; on in `fast` mode stores candidates without adding `fast`'s skipped `SIMILAR_TO` / `SEMANTICALLY_RELATED` edges. `index_repository` also takes `doc_candidates` for a single index, which wins over this setting. Applies from the next index. |
| `watcher_enabled` | `true` | Master switch for the background watcher subsystem. Set `false` to stop the watcher from starting at all — no poll thread and no project registration. Reindex manually with `index_repository` when disabled. Active MCP sessions can register their root project and successful explicit index targets; under `daemon start` those watches outlive the session until the daemon stops, the project is deleted, its directory disappears, or `auto_watch` is set to `false`. `index_status` reports the current state in its `watch` object. |
@@ -142,6 +143,44 @@ and preserves any previously serving database. See
[Index resource limits](INDEX_RESOURCE_LIMITS.md) for counting, validation, and
error-response details.
### `ignore_worktrees`
Every indexed project is registered under its own absolute root path, so each
linked worktree becomes a separate permanent index. On machines that create many
short-lived worktrees, the automatic paths (`auto_index`, and the session hook's
"index this project first" guidance) turn every throwaway checkout into another
stored index of what is largely the same repository.
Enable the key to keep those checkouts out of the index:
```bash
codebase-memory-mcp config set ignore_worktrees true
```
With it enabled:
- automatic indexing skips a session whose root is a linked worktree;
- the `hook-augment` context says the worktree is unindexed on purpose instead
of telling the agent to run `index_repository`;
- an explicit `index_repository` call on a linked worktree is refused, and names
both ways forward — pass `index_worktree=true` for that one call, or turn the
key back off.
The main checkout of the same repository is unaffected, as are ordinary clones
and submodules. Detection is git plumbing only: a linked worktree's `.git` is a
file pointing at a gitdir that contains a `commondir` entry.
A subdirectory counts as the worktree it sits in. Detection walks up from the
given path to the nearest `.git` entry, so `index_repository` on any
subdirectory of a linked worktree is refused the same way, and a session root or
hook working directory inside one is treated as that worktree. The walk stops at
the first `.git` it finds; a main checkout or a submodule ends it as "not a
worktree". A path outside any git checkout is checked one directory at a time up
to the filesystem root and is never treated as a worktree. None of this runs
while the key is off.
The default is `false`, so indexing behavior is unchanged unless you opt in.
## 3. UI Settings
The optional built-in graph UI stores its settings in:
docs/EVALUATION_PLAN.md
+19 -5
View File
@@ -274,8 +274,7 @@ then its index is **deleted** before the next language — so **only one project
every index is genuinely cold. The skeleton:
```bash
# Start clean: no leftover DBs, fresh results tree
rm -f ~/.cache/codebase-memory-mcp/*.db
# Start clean: fresh results tree
mkdir -p /tmp/eval-results
for lang in $ALL_LANGS; do # ALL_LANGS = full 159-name list (§2 / §8)
@@ -283,8 +282,13 @@ for lang in $ALL_LANGS; do # ALL_LANGS = full 159-name list
# --- step 2: cold index in the main channel, TIMED (key metric) ---
t0=$(now_ms)
CBM_BENCH_KEEP_RUNTIME=1 \
scripts/benchmark-index.sh ~/.local/bin/codebase-memory-mcp "$lang" /tmp/bench/"$lang" /tmp/eval-results
index_ms=$(( $(now_ms) - t0 )) # clone+index wall-clock → manifest + report (§5)
# The harness indexes into a run-private root (#1696). CBM_BENCH_KEEP_RUNTIME leaves that
# root behind on success and records its paths; the graph session in steps 4-7 must be
# started with these CBM_RUNTIME_DIR / CBM_CACHE_DIR, and step 8 removes the root.
set -a; . /tmp/eval-results/"$lang"/runtime-root.txt; set +a
# --- step 3: record per-type histograms (zeros back-filled) ---
# node-types.json, edge-types.json (every label + all 32 edge types, zeros kept, §7 below)
@@ -293,7 +297,14 @@ for lang in $ALL_LANGS; do # ALL_LANGS = full 159-name list
# + per-language report + (deferred, blind) judge ---
# --- step 8: delete THIS language's index so the next is cold, then mark done ---
rm -f ~/.cache/codebase-memory-mcp/*.db
# The graph session (steps 4-7) may still have a daemon running under the kept
# CBM_RUNTIME_DIR (exported above); stop it before its root goes away. A refused
# stop (a session still attached) means the root is still in use: keep it.
if ~/.local/bin/codebase-memory-mcp daemon stop; then
rm -rf -- "$CBM_BENCH_RUNTIME_ROOT"
else
echo "$lang: daemon under $CBM_RUNTIME_DIR did not stop; keeping $CBM_BENCH_RUNTIME_ROOT" >&2
fi
manifest_mark_done "$lang" "$index_ms"
done
```
@@ -860,10 +871,13 @@ Deep-Dive section.
# 1. Clone all 159 repos (shallow; skip existing)
scripts/clone-bench-repos.sh /tmp/bench
# 2. Cold index all 159 (LSP cohort in full mode)
rm -f ~/.cache/codebase-memory-mcp/*.db
# 2. Cold index all 159 (LSP cohort in full mode). Each language is indexed into a run-private
# runtime and cache (#1696); CBM_BENCH_KEEP_RUNTIME=1 keeps that root after a successful
# index and records its paths in /tmp/eval-results/<lang>/runtime-root.txt. Source it
# before the graph phase, then stop the daemon and remove the root, as in §7 step 8.
mkdir -p /tmp/eval-results
for lang in $ALL_LANGS; do
CBM_BENCH_KEEP_RUNTIME=1 \
scripts/benchmark-index.sh ~/.local/bin/codebase-memory-mcp "$lang" /tmp/bench/"$lang" /tmp/eval-results
done
install.sh
+11
View File
@@ -148,8 +148,19 @@ detect_arch() {
esac
}
is_android() {
[ "$(uname -o 2>/dev/null || true)" = "Android" ] \
|| [ -n "${TERMUX_VERSION:-}" ] \
|| [[ "${PREFIX:-}" == /data/data/com.termux/* ]]
}
OS=$(detect_os)
ARCH=$(detect_arch)
if [ "$OS" = "linux" ] && is_android; then
echo 'error: Android/Termux cannot run the Linux portable binary (static glibc; Android kills it with "Bad system call").' >&2
echo "Building from source in Termux may work but is not a supported platform yet - see issue #1202." >&2
exit 1
fi
echo "codebase-memory-mcp installer"
echo " os: $OS"
internal/cbm/cbm.c
+7
View File
@@ -16,6 +16,7 @@
#include "lsp/php_lsp.h"
#include "lsp/perl_lsp.h"
#include "lsp/py_lsp.h"
#include "lsp/ruby_lsp.h"
#include "lsp/ts_lsp.h"
#include "lsp/cs_lsp.h"
#include "lsp/java_lsp.h"
@@ -3907,6 +3908,9 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, C
// OpenAPI operations as Routes (self-gated: API description documents).
cbm_extract_openapi(&ctx);
// Next.js App Router handlers' routes (self-gated: app/**/route.ts and route.js).
cbm_extract_nextjs_routes(&ctx);
// K8s / Kustomize semantic pass (additional structured extraction for YAML-based infra files).
if (ctx.language == CBM_LANG_KUSTOMIZE || ctx.language == CBM_LANG_K8S) {
cbm_extract_k8s(&ctx);
@@ -3948,6 +3952,9 @@ static CBMFileResult *extract_file_ex_body(const char *source, int source_len, C
if (language == CBM_LANG_PERL) {
cbm_run_perl_lsp(a, result, source, source_len, root);
}
if (language == CBM_LANG_RUBY) {
cbm_run_ruby_lsp(a, result, source, source_len, root);
}
if (language == CBM_LANG_PYTHON) {
cbm_run_py_lsp(a, result, source, source_len, root);
}
internal/cbm/cbm.h
+5
View File
@@ -1409,6 +1409,11 @@ void cbm_extract_diagram_file(CBMExtractCtx *ctx);
* or JSON files whose root says `openapi` or `swagger`. */
void cbm_extract_openapi(CBMExtractCtx *ctx);
/* Next.js App Router route handlers (extract_nextjs.c): the HTTP verb Functions
* a route file exports carry the route path its directories name. Self-gated:
* TS / JS route.ts and route.js under app/ or src/app/. */
void cbm_extract_nextjs_routes(CBMExtractCtx *ctx);
/* Canonicalize route-path parameter placeholders (":id", "{id}", "<id>",
* "${...}") to a single "{}" token so that client call sites, server handlers
* and OpenAPI operations rendezvous on the same Route QN regardless of
internal/cbm/extract_nextjs.c
+272
View File
@@ -0,0 +1,272 @@
/*
* extract_nextjs.c -- Next.js App Router route handlers (#759): an HTTP verb a
* route file (`app/.../route.ts` or `route.js`, the app directory at the root
* or under src/) exports serves the path its directories name.
*
* The handler is the Function definition extraction already made for the
* export: this fills its route_path / route_method, so its Route node and
* HANDLES edge come from the route pass exactly as a decorator route's do, on
* a full and on an incremental index alike. The path is spelled as SvelteKit's
* (sveltekit_route_path, pass_route_nodes.c): `[id]` is `:id`, `[...slug]` is
* `*slug` and a `(group)` directory adds no segment.
*
* A directory this cannot spell makes the file no route at all: an optional
* catch-all (`[[...slug]]`), a private folder (`_lib`), a parallel slot
* (`@modal`), an intercepting route (`(.)photo`), a malformed bracket, or a
* path that does not fit route_path. A handler is a Function of this file:
* `export [async] function GET`, `export const GET = [async] (...) => ...`,
* or `export { GET }` of such a declaration. A renamed
* (`export { handler as GET }`), re-exported, destructured or wrapped
* (`export const GET = auth(handler)`) handler, or a `function` expression
* bound to a const, has no Function of its own here and is not routed. Each
* file is judged alone: a src/app/ route file is routed even where a root
* app/ directory makes Next.js ignore src/app/.
*/
#include "cbm.h"
#include "foundation/arena.h"
#include "helpers.h"
#include "tree_sitter/api.h"
#include "foundation/constants.h"
#include <stdbool.h>
#include <stdint.h>
#include <string.h>
enum {
NX_PATH_MAX = CBM_SZ_256, /* the route pass rebuilds a Route from this much */
NX_REST_LEN = 3, /* "..." */
};
/* The path of a route file below its app directory, NULL for any other file. */
static const char *nx_app_relative(const char *rel_path) {
const char *base = rel_path ? strrchr(rel_path, '/') : NULL;
if (!base || (strcmp(base, "/route.ts") != 0 && strcmp(base, "/route.js") != 0)) {
return NULL;
}
if (strncmp(rel_path, "app/", strlen("app/")) == 0) {
return rel_path + strlen("app/");
}
if (strncmp(rel_path, "src/app/", strlen("src/app/")) == 0) {
return rel_path + strlen("src/app/");
}
return NULL;
}
static bool nx_has_any(const char *s, size_t n, const char *chars) {
for (size_t i = 0; i < n; i++) {
if (strchr(chars, s[i])) {
return true;
}
}
return false;
}
/* Append directory segment seg (n bytes) to the route path out[*len]. False
* when the segment cannot be spelled or the path would not fit. */
static bool nx_append_segment(char *out, size_t *len, const char *seg, size_t n) {
if (n == 0 || seg[0] == '_' || seg[0] == '@') {
return false;
}
if (seg[0] == '(') {
/* A route group adds nothing; `(.)x`, `(..)x` and `(...)x` intercept. */
return n > PAIR_LEN && seg[n - SKIP_ONE] == ')' && seg[SKIP_ONE] != '.' &&
!nx_has_any(seg + SKIP_ONE, n - PAIR_LEN, "()");
}
char marker = '\0';
if (seg[0] == '[') {
if (seg[n - SKIP_ONE] != ']') {
return false;
}
marker = ':';
seg += SKIP_ONE;
n -= PAIR_LEN;
if (n >= NX_REST_LEN && strncmp(seg, "...", NX_REST_LEN) == 0) {
marker = '*';
seg += NX_REST_LEN;
n -= NX_REST_LEN;
}
if (n == 0 || nx_has_any(seg, n, "[].")) {
return false;
}
} else if (nx_has_any(seg, n, "[]")) {
return false;
}
size_t need = SKIP_ONE + (marker ? SKIP_ONE : 0) + n;
if (*len + need >= NX_PATH_MAX) {
return false;
}
out[(*len)++] = '/';
if (marker) {
out[(*len)++] = marker;
}
memcpy(out + *len, seg, n);
*len += n;
out[*len] = '\0';
return true;
}
/* The route path of the file being extracted, in the arena; NULL for none. */
static const char *nx_route_path(CBMExtractCtx *ctx) {
const char *seg = nx_app_relative(ctx->rel_path);
if (!seg) {
return NULL;
}
const char *base = strrchr(ctx->rel_path, '/');
char path[NX_PATH_MAX] = "/";
size_t len = 0;
while (seg < base) {
const char *end = strchr(seg, '/');
if (!nx_append_segment(path, &len, seg, (size_t)(end - seg))) {
return NULL;
}
seg = end + SKIP_ONE;
}
return cbm_arena_strdup(ctx->arena, path);
}
static bool nx_is_method(const char *name) {
static const char *const methods[] = {"GET", "POST", "PUT", "PATCH",
"DELETE", "HEAD", "OPTIONS"};
for (size_t i = 0; i < sizeof(methods) / sizeof(methods[0]); i++) {
if (strcmp(name, methods[i]) == 0) {
return true;
}
}
return false;
}
static bool nx_is(TSNode n, const char *type) {
return !ts_node_is_null(n) && strcmp(ts_node_type(n), type) == 0;
}
/* Does a node carry the anonymous keyword child kw (`default`, `type`)? */
static bool nx_has_keyword(TSNode n, const char *kw) {
uint32_t count = ts_node_child_count(n);
for (uint32_t i = 0; i < count; i++) {
TSNode c = ts_node_child(n, i);
if (!ts_node_is_named(c) && strcmp(ts_node_type(c), kw) == 0) {
return true;
}
}
return false;
}
/* The name of a declarator whose value is an arrow function, the Function
* extraction names after the binding (`GET = () => ...`); a null node for any
* other declarator. */
static TSNode nx_arrow_binding(TSNode declarator) {
TSNode value = ts_node_child_by_field_name(declarator, TS_FIELD("value"));
TSNode name = ts_node_child_by_field_name(declarator, TS_FIELD("name"));
if (!nx_is(name, "identifier") || !nx_is(value, "arrow_function")) {
return (TSNode){0};
}
return name;
}
/* Route the Function definition named by name_node, declared inside decl. */
static void nx_route_handler(CBMExtractCtx *ctx, TSNode decl, TSNode name_node, const char *path) {
const char *name = cbm_node_text(ctx->arena, name_node, ctx->source);
if (!name || !nx_is_method(name)) {
return;
}
const char *qn =
cbm_fqn_compute_source_lang(ctx->arena, ctx->project, ctx->rel_path, name, ctx->language);
uint32_t first = ts_node_start_point(decl).row + TS_LINE_OFFSET;
uint32_t last = ts_node_end_point(decl).row + TS_LINE_OFFSET;
for (int i = 0; qn && i < ctx->result->defs.count; i++) {
CBMDefinition *def = &ctx->result->defs.items[i];
if (!def->route_path && def->label && def->qualified_name &&
strcmp(def->label, "Function") == 0 && strcmp(def->qualified_name, qn) == 0 &&
def->start_line >= first && def->end_line <= last) {
def->route_path = path;
def->route_method = name;
return;
}
}
}
/* Does the name node, if any, spell want? Any name does when want is NULL. */
static bool nx_wanted(CBMExtractCtx *ctx, TSNode name, const char *want) {
if (ts_node_is_null(name)) {
return false;
}
const char *text = want ? cbm_node_text(ctx->arena, name, ctx->source) : NULL;
return !want || (text && strcmp(text, want) == 0);
}
/* Route the handlers a top-level declaration (function or const) defines.
* Only names equal to want are considered when want is set. */
static void nx_route_declaration(CBMExtractCtx *ctx, TSNode decl, const char *path,
const char *want) {
if (nx_is(decl, "function_declaration")) {
TSNode name = ts_node_child_by_field_name(decl, TS_FIELD("name"));
if (nx_wanted(ctx, name, want)) {
nx_route_handler(ctx, decl, name, path);
}
return;
}
if (!nx_is(decl, "lexical_declaration") && !nx_is(decl, "variable_declaration")) {
return;
}
uint32_t count = ts_node_named_child_count(decl);
for (uint32_t i = 0; i < count; i++) {
TSNode declarator = ts_node_named_child(decl, i);
TSNode name =
nx_is(declarator, "variable_declarator") ? nx_arrow_binding(declarator) : (TSNode){0};
if (nx_wanted(ctx, name, want)) {
nx_route_handler(ctx, declarator, name, path);
}
}
}
/* `export { GET }`: route the file's own top-level declaration of each
* unrenamed, non-type specifier. */
static void nx_route_export_clause(CBMExtractCtx *ctx, TSNode clause, const char *path) {
uint32_t count = ts_node_named_child_count(clause);
uint32_t top = ts_node_named_child_count(ctx->root);
for (uint32_t i = 0; i < count; i++) {
TSNode spec = ts_node_named_child(clause, i);
TSNode name = ts_node_child_by_field_name(spec, TS_FIELD("name"));
if (!nx_is(spec, "export_specifier") || !nx_is(name, "identifier") ||
!ts_node_is_null(ts_node_child_by_field_name(spec, TS_FIELD("alias"))) ||
nx_has_keyword(spec, "type") || nx_has_keyword(spec, "typeof")) {
continue;
}
const char *want = cbm_node_text(ctx->arena, name, ctx->source);
for (uint32_t j = 0; want && j < top; j++) {
nx_route_declaration(ctx, ts_node_named_child(ctx->root, j), path, want);
}
}
}
void cbm_extract_nextjs_routes(CBMExtractCtx *ctx) {
if (ctx->language != CBM_LANG_TYPESCRIPT && ctx->language != CBM_LANG_JAVASCRIPT) {
return;
}
const char *path = nx_route_path(ctx);
if (!path) {
return;
}
uint32_t count = ts_node_named_child_count(ctx->root);
for (uint32_t i = 0; i < count; i++) {
TSNode node = ts_node_named_child(ctx->root, i);
/* A runtime export of this file: not `export default`, not
* `export type { ... }`, not a re-export `... from './x'`. */
if (!nx_is(node, "export_statement") || nx_has_keyword(node, "default") ||
nx_has_keyword(node, "type") ||
!ts_node_is_null(ts_node_child_by_field_name(node, TS_FIELD("source")))) {
continue;
}
TSNode decl = ts_node_child_by_field_name(node, TS_FIELD("declaration"));
if (!ts_node_is_null(decl)) {
nx_route_declaration(ctx, decl, path, NULL);
continue;
}
uint32_t parts = ts_node_named_child_count(node);
for (uint32_t j = 0; j < parts; j++) {
TSNode part = ts_node_named_child(node, j);
if (nx_is(part, "export_clause")) {
nx_route_export_clause(ctx, part, path);
}
}
}
}
internal/cbm/lsp/generated/ruby_stdlib_data.c
+465
View File
@@ -0,0 +1,465 @@
/*
* ruby_stdlib_data.c — hand-written Ruby core + curated Rails type data.
*
* Strategy mirrors perl_stdlib_data.c / php_stdlib_data.c:
* 1. Ruby core classes (String, Array, Hash, Integer, ...) registered as
* types with receiver-keyed instance methods whose return types enable
* call-chain typing ("a,b".split(",").first). Method QNs are bare
* ("String.upcase") — no project prefix — so they can never collide
* with an indexed def; they exist for TYPING, not for edge emission
* (the resolver only emits edges to project-defined methods).
* 2. Kernel built-ins (puts, require, raise, ...) as global functions so
* bare calls to them type-check without producing spurious edges.
* 3. A curated Rails surface: ActiveRecord::Base class-side query methods
* and instance persistence methods, ActionController::Base helpers,
* and ActiveSupport-style predicates on Object. Registered under
* dotted QNs ("ActiveRecord.Base") to match ruby path dotting
* (Foo::Bar -> Foo.Bar). The resolver special-cases ActiveRecord
* query methods to return the *receiving model's* type (User.find ->
* User), which these generic entries cannot express.
*
* Return types are left UNKNOWN where the real type is polymorphic; the
* seed only needs to be right where chaining matters.
*/
#include "../type_rep.h"
#include "../type_registry.h"
#include "../../arena.h"
#include "../ruby_lsp.h"
#include <string.h>
#define MIXED cbm_type_unknown()
/* Register a type by bare dotted QN (e.g. "String", "ActiveRecord.Base"). */
#define REG_TYPE(qn_) \
do { \
CBMRegisteredType rt; \
memset(&rt, 0, sizeof(rt)); \
rt.qualified_name = (qn_); \
rt.short_name = (qn_); \
cbm_registry_add_type(reg, rt); \
} while (0)
/* Signature `() -> ret`. Every seed allocation can fail (arena exhausted):
* a NULL return vector is left out, so the signature types as unknown (the
* same fallback ruby_register_method uses) instead of being written through. */
static const CBMType *ruby_seed_signature(CBMArena *arena, const CBMType *ret) {
const CBMType **rets = (const CBMType **)cbm_arena_alloc(arena, 2 * sizeof(*rets));
if (rets) {
rets[0] = ret;
rets[1] = NULL;
}
return cbm_type_func(arena, NULL, NULL, rets);
}
/* Register an instance method on receiver type `recv_` returning `ret_`.
* An entry whose formatted QN came back NULL is not registered: a NULL QN
* would reach strcmp in finalize and in every later lookup. */
#define REG_METHOD(recv_, name_, ret_) \
do { \
memset(&rf, 0, sizeof(rf)); \
rf.min_params = -1; \
rf.qualified_name = cbm_arena_sprintf(arena, "%s.%s", (recv_), (name_)); \
if (!rf.qualified_name) \
break; \
rf.short_name = (name_); \
rf.receiver_type = (recv_); \
rf.signature = ruby_seed_signature(arena, (ret_)); \
cbm_registry_add_func(reg, rf); \
} while (0)
/* Register a singleton (class-side) method: receiver key "<qn>.self"
* matches ruby_lookup_singleton_method's keying convention. Skipped when
* either formatted name came back NULL (see REG_METHOD). */
#define REG_SMETHOD(recv_, name_, ret_) \
do { \
memset(&rf, 0, sizeof(rf)); \
rf.min_params = -1; \
rf.qualified_name = cbm_arena_sprintf(arena, "%s.%s", (recv_), (name_)); \
rf.receiver_type = cbm_arena_sprintf(arena, "%s.self", (recv_)); \
if (!rf.qualified_name || !rf.receiver_type) \
break; \
rf.short_name = (name_); \
rf.signature = ruby_seed_signature(arena, (ret_)); \
cbm_registry_add_func(reg, rf); \
} while (0)
/* Register a global (Kernel) built-in function returning `ret_`. */
#define REG_BUILTIN(name_, ret_) \
do { \
memset(&rf, 0, sizeof(rf)); \
rf.min_params = -1; \
rf.qualified_name = (name_); \
rf.short_name = (name_); \
rf.signature = ruby_seed_signature(arena, (ret_)); \
cbm_registry_add_func(reg, rf); \
} while (0)
void cbm_ruby_stdlib_register(CBMTypeRegistry *reg, CBMArena *arena) {
CBMRegisteredFunc rf;
const CBMType *T_STRING = cbm_type_named(arena, "String");
const CBMType *T_ARRAY = cbm_type_named(arena, "Array");
const CBMType *T_HASH = cbm_type_named(arena, "Hash");
const CBMType *T_INT = cbm_type_named(arena, "Integer");
const CBMType *T_FLOAT = cbm_type_named(arena, "Float");
const CBMType *T_SYM = cbm_type_named(arena, "Symbol");
const CBMType *T_BOOL = cbm_type_builtin(arena, "bool");
/* ── Core class constants (resolvable as superclasses / receivers) ── */
static const char *core_types[] = {"Object",
"BasicObject",
"String",
"Array",
"Hash",
"Integer",
"Float",
"Numeric",
"Symbol",
"Range",
"Regexp",
"Time",
"Date",
"DateTime",
"File",
"IO",
"Dir",
"Struct",
"OpenStruct",
"StringIO",
"Set",
"Proc",
"Method",
"Thread",
"Mutex",
"Queue",
"Rational",
"Complex",
"NilClass",
"TrueClass",
"FalseClass",
"Exception",
"StandardError",
"RuntimeError",
"ArgumentError",
"TypeError",
"NameError",
"NoMethodError",
"IOError",
"KeyError",
"IndexError",
"RangeError",
"NotImplementedError",
"StopIteration",
"Comparable",
"Enumerable",
"Kernel",
"Math",
"JSON",
"ERB",
"Logger",
"Enumerator",
NULL};
for (int i = 0; core_types[i]; i++)
REG_TYPE(core_types[i]);
/* ── String ── */
REG_METHOD("String", "upcase", T_STRING);
REG_METHOD("String", "downcase", T_STRING);
REG_METHOD("String", "capitalize", T_STRING);
REG_METHOD("String", "strip", T_STRING);
REG_METHOD("String", "chomp", T_STRING);
REG_METHOD("String", "gsub", T_STRING);
REG_METHOD("String", "sub", T_STRING);
REG_METHOD("String", "split", T_ARRAY);
REG_METHOD("String", "chars", T_ARRAY);
REG_METHOD("String", "lines", T_ARRAY);
REG_METHOD("String", "bytes", T_ARRAY);
REG_METHOD("String", "to_s", T_STRING);
REG_METHOD("String", "to_str", T_STRING);
REG_METHOD("String", "to_i", T_INT);
REG_METHOD("String", "to_f", T_FLOAT);
REG_METHOD("String", "to_sym", T_SYM);
REG_METHOD("String", "length", T_INT);
REG_METHOD("String", "size", T_INT);
REG_METHOD("String", "reverse", T_STRING);
REG_METHOD("String", "include?", T_BOOL);
REG_METHOD("String", "start_with?", T_BOOL);
REG_METHOD("String", "end_with?", T_BOOL);
REG_METHOD("String", "empty?", T_BOOL);
REG_METHOD("String", "match?", T_BOOL);
REG_METHOD("String", "freeze", T_STRING);
REG_METHOD("String", "dup", T_STRING);
/* ── Array ── */
REG_METHOD("Array", "map", T_ARRAY);
REG_METHOD("Array", "flat_map", T_ARRAY);
REG_METHOD("Array", "select", T_ARRAY);
REG_METHOD("Array", "filter", T_ARRAY);
REG_METHOD("Array", "reject", T_ARRAY);
REG_METHOD("Array", "sort", T_ARRAY);
REG_METHOD("Array", "sort_by", T_ARRAY);
REG_METHOD("Array", "uniq", T_ARRAY);
REG_METHOD("Array", "compact", T_ARRAY);
REG_METHOD("Array", "flatten", T_ARRAY);
REG_METHOD("Array", "reverse", T_ARRAY);
REG_METHOD("Array", "concat", T_ARRAY);
REG_METHOD("Array", "push", T_ARRAY);
REG_METHOD("Array", "join", T_STRING);
REG_METHOD("Array", "first", MIXED);
REG_METHOD("Array", "last", MIXED);
REG_METHOD("Array", "sample", MIXED);
REG_METHOD("Array", "length", T_INT);
REG_METHOD("Array", "size", T_INT);
REG_METHOD("Array", "count", T_INT);
REG_METHOD("Array", "sum", MIXED);
REG_METHOD("Array", "min", MIXED);
REG_METHOD("Array", "max", MIXED);
REG_METHOD("Array", "include?", T_BOOL);
REG_METHOD("Array", "empty?", T_BOOL);
REG_METHOD("Array", "any?", T_BOOL);
REG_METHOD("Array", "all?", T_BOOL);
REG_METHOD("Array", "none?", T_BOOL);
REG_METHOD("Array", "each", T_ARRAY);
REG_METHOD("Array", "each_with_index", T_ARRAY);
REG_METHOD("Array", "to_a", T_ARRAY);
REG_METHOD("Array", "group_by", T_HASH);
REG_METHOD("Array", "each_slice", MIXED);
REG_METHOD("Array", "zip", T_ARRAY);
/* ── Hash ── */
REG_METHOD("Hash", "keys", T_ARRAY);
REG_METHOD("Hash", "values", T_ARRAY);
REG_METHOD("Hash", "merge", T_HASH);
REG_METHOD("Hash", "merge!", T_HASH);
REG_METHOD("Hash", "fetch", MIXED);
REG_METHOD("Hash", "dig", MIXED);
REG_METHOD("Hash", "key?", T_BOOL);
REG_METHOD("Hash", "has_key?", T_BOOL);
REG_METHOD("Hash", "include?", T_BOOL);
REG_METHOD("Hash", "empty?", T_BOOL);
REG_METHOD("Hash", "size", T_INT);
REG_METHOD("Hash", "length", T_INT);
REG_METHOD("Hash", "count", T_INT);
REG_METHOD("Hash", "each", T_HASH);
REG_METHOD("Hash", "map", T_ARRAY);
REG_METHOD("Hash", "select", T_HASH);
REG_METHOD("Hash", "reject", T_HASH);
REG_METHOD("Hash", "to_a", T_ARRAY);
REG_METHOD("Hash", "to_h", T_HASH);
REG_METHOD("Hash", "transform_values", T_HASH);
REG_METHOD("Hash", "transform_keys", T_HASH);
REG_METHOD("Hash", "symbolize_keys", T_HASH); /* ActiveSupport */
REG_METHOD("Hash", "stringify_keys", T_HASH); /* ActiveSupport */
REG_METHOD("Hash", "deep_symbolize_keys", T_HASH);
REG_METHOD("Hash", "with_indifferent_access", T_HASH);
/* ── Integer / Float ── */
REG_METHOD("Integer", "to_s", T_STRING);
REG_METHOD("Integer", "to_i", T_INT);
REG_METHOD("Integer", "to_f", T_FLOAT);
REG_METHOD("Integer", "times", MIXED);
REG_METHOD("Integer", "upto", MIXED);
REG_METHOD("Integer", "abs", T_INT);
REG_METHOD("Integer", "zero?", T_BOOL);
REG_METHOD("Integer", "positive?", T_BOOL);
REG_METHOD("Integer", "negative?", T_BOOL);
REG_METHOD("Integer", "even?", T_BOOL);
REG_METHOD("Integer", "odd?", T_BOOL);
REG_METHOD("Float", "to_s", T_STRING);
REG_METHOD("Float", "to_i", T_INT);
REG_METHOD("Float", "round", T_INT);
REG_METHOD("Float", "ceil", T_INT);
REG_METHOD("Float", "floor", T_INT);
REG_METHOD("Float", "abs", T_FLOAT);
/* ── Symbol / misc ── */
REG_METHOD("Symbol", "to_s", T_STRING);
REG_METHOD("Symbol", "to_sym", T_SYM);
REG_METHOD("Symbol", "to_proc", cbm_type_named(arena, "Proc"));
REG_METHOD("Range", "to_a", T_ARRAY);
REG_METHOD("Range", "each", MIXED);
REG_METHOD("Range", "map", T_ARRAY);
REG_METHOD("Range", "include?", T_BOOL);
REG_METHOD("Time", "to_s", T_STRING);
REG_METHOD("Time", "to_i", T_INT);
REG_METHOD("Time", "strftime", T_STRING);
REG_METHOD("Time", "year", T_INT);
REG_METHOD("Time", "month", T_INT);
REG_METHOD("Time", "day", T_INT);
REG_SMETHOD("Time", "now", cbm_type_named(arena, "Time"));
REG_SMETHOD("Time", "at", cbm_type_named(arena, "Time"));
REG_SMETHOD("Time", "parse", cbm_type_named(arena, "Time"));
REG_SMETHOD("Time", "current", cbm_type_named(arena, "Time")); /* ActiveSupport */
REG_SMETHOD("Time", "zone", MIXED);
REG_SMETHOD("File", "read", T_STRING);
REG_SMETHOD("File", "readlines", T_ARRAY);
REG_SMETHOD("File", "open", cbm_type_named(arena, "File"));
REG_SMETHOD("File", "exist?", T_BOOL);
REG_SMETHOD("File", "basename", T_STRING);
REG_SMETHOD("File", "dirname", T_STRING);
REG_SMETHOD("File", "join", T_STRING);
REG_SMETHOD("File", "expand_path", T_STRING);
REG_SMETHOD("JSON", "parse", MIXED);
REG_SMETHOD("JSON", "generate", T_STRING);
REG_SMETHOD("JSON", "pretty_generate", T_STRING);
REG_SMETHOD("Math", "sqrt", T_FLOAT);
REG_SMETHOD("Math", "pow", T_FLOAT);
REG_SMETHOD("Math", "sin", T_FLOAT);
REG_SMETHOD("Math", "cos", T_FLOAT);
REG_SMETHOD("Math", "log", T_FLOAT);
/* ── Object (universal receivers; ActiveSupport predicates) ── */
REG_METHOD("Object", "to_s", T_STRING);
REG_METHOD("Object", "inspect", T_STRING);
REG_METHOD("Object", "freeze", MIXED);
REG_METHOD("Object", "frozen?", T_BOOL);
REG_METHOD("Object", "dup", MIXED);
REG_METHOD("Object", "clone", MIXED);
REG_METHOD("Object", "tap", MIXED);
REG_METHOD("Object", "then", MIXED);
REG_METHOD("Object", "nil?", T_BOOL);
REG_METHOD("Object", "is_a?", T_BOOL);
REG_METHOD("Object", "kind_of?", T_BOOL);
REG_METHOD("Object", "instance_of?", T_BOOL);
REG_METHOD("Object", "respond_to?", T_BOOL);
REG_METHOD("Object", "blank?", T_BOOL); /* ActiveSupport */
REG_METHOD("Object", "present?", T_BOOL); /* ActiveSupport */
REG_METHOD("Object", "presence", MIXED); /* ActiveSupport */
REG_METHOD("Object", "to_json", T_STRING); /* ActiveSupport / json */
/* ── Kernel built-ins (global functions) ── */
REG_BUILTIN("puts", MIXED);
REG_BUILTIN("print", MIXED);
REG_BUILTIN("p", MIXED);
REG_BUILTIN("pp", MIXED);
REG_BUILTIN("require", T_BOOL);
REG_BUILTIN("require_relative", T_BOOL);
REG_BUILTIN("raise", MIXED);
REG_BUILTIN("fail", MIXED);
REG_BUILTIN("loop", MIXED);
REG_BUILTIN("sleep", T_INT);
REG_BUILTIN("rand", MIXED);
REG_BUILTIN("format", T_STRING);
REG_BUILTIN("sprintf", T_STRING);
REG_BUILTIN("gets", T_STRING);
REG_BUILTIN("exit", MIXED);
REG_BUILTIN("abort", MIXED);
REG_BUILTIN("lambda", cbm_type_named(arena, "Proc"));
REG_BUILTIN("proc", cbm_type_named(arena, "Proc"));
REG_BUILTIN("binding", MIXED);
REG_BUILTIN("catch", MIXED);
REG_BUILTIN("throw", MIXED);
REG_BUILTIN("attr_accessor", MIXED);
REG_BUILTIN("attr_reader", MIXED);
REG_BUILTIN("attr_writer", MIXED);
/* ── Rails: ActiveRecord::Base ──────────────────────────────────
* Class-side query interface. Return types here are generic; the
* resolver's AR special case substitutes the receiving model's type
* (User.find -> User) when the receiver's ancestry reaches
* ActiveRecord.Base / ApplicationRecord. */
REG_TYPE("ActiveRecord.Base");
REG_TYPE("ApplicationRecord");
static const char *ar_class_methods[] = {"find",
"find_by",
"find_by!",
"find_or_create_by",
"find_or_initialize_by",
"where",
"all",
"first",
"last",
"take",
"create",
"create!",
"new",
"count",
"order",
"limit",
"offset",
"joins",
"left_joins",
"includes",
"preload",
"eager_load",
"group",
"having",
"distinct",
"pluck",
"ids",
"exists?",
"none",
"unscoped",
"select",
"sum",
"maximum",
"minimum",
"average",
"destroy_all",
"delete_all",
"update_all",
"transaction",
"find_each",
NULL};
for (int i = 0; ar_class_methods[i]; i++)
REG_SMETHOD("ActiveRecord.Base", ar_class_methods[i], MIXED);
REG_METHOD("ActiveRecord.Base", "save", T_BOOL);
REG_METHOD("ActiveRecord.Base", "save!", T_BOOL);
REG_METHOD("ActiveRecord.Base", "update", T_BOOL);
REG_METHOD("ActiveRecord.Base", "update!", T_BOOL);
REG_METHOD("ActiveRecord.Base", "destroy", MIXED);
REG_METHOD("ActiveRecord.Base", "destroy!", MIXED);
REG_METHOD("ActiveRecord.Base", "delete", MIXED);
REG_METHOD("ActiveRecord.Base", "reload", MIXED);
REG_METHOD("ActiveRecord.Base", "valid?", T_BOOL);
REG_METHOD("ActiveRecord.Base", "invalid?", T_BOOL);
REG_METHOD("ActiveRecord.Base", "persisted?", T_BOOL);
REG_METHOD("ActiveRecord.Base", "new_record?", T_BOOL);
REG_METHOD("ActiveRecord.Base", "errors", MIXED);
REG_METHOD("ActiveRecord.Base", "attributes", T_HASH);
REG_METHOD("ActiveRecord.Base", "assign_attributes", MIXED);
REG_METHOD("ActiveRecord.Base", "update_attribute", T_BOOL);
REG_METHOD("ActiveRecord.Base", "touch", T_BOOL);
REG_METHOD("ActiveRecord.Base", "id", T_INT);
/* ── Rails: ActionController::Base / ::API ── */
REG_TYPE("ActionController.Base");
REG_TYPE("ActionController.API");
static const char *ac_receivers[] = {"ActionController.Base", "ActionController.API", NULL};
for (int i = 0; ac_receivers[i]; i++) {
const char *acr = ac_receivers[i];
REG_METHOD(acr, "render", MIXED);
REG_METHOD(acr, "redirect_to", MIXED);
REG_METHOD(acr, "head", MIXED);
REG_METHOD(acr, "params", MIXED);
REG_METHOD(acr, "session", MIXED);
REG_METHOD(acr, "cookies", MIXED);
REG_METHOD(acr, "request", MIXED);
REG_METHOD(acr, "response", MIXED);
REG_METHOD(acr, "respond_to", MIXED);
REG_METHOD(acr, "flash", MIXED);
}
REG_SMETHOD("ActionController.Base", "before_action", MIXED);
REG_SMETHOD("ActionController.Base", "after_action", MIXED);
REG_SMETHOD("ActionController.Base", "skip_before_action", MIXED);
REG_SMETHOD("ActionController.API", "before_action", MIXED);
REG_SMETHOD("ActionController.API", "after_action", MIXED);
/* ── Rails: jobs / mailers (constants only, for superclass chains) ── */
REG_TYPE("ActiveJob.Base");
REG_TYPE("ApplicationJob");
REG_TYPE("ActionMailer.Base");
REG_TYPE("ApplicationMailer");
REG_TYPE("ApplicationController");
REG_SMETHOD("ActiveJob.Base", "perform_later", MIXED);
REG_SMETHOD("ActiveJob.Base", "perform_now", MIXED);
REG_SMETHOD("ActiveJob.Base", "set", MIXED);
REG_METHOD("ActionMailer.Base", "mail", MIXED);
REG_SMETHOD("ActionMailer.Base", "with", MIXED);
/* ── Minitest/RSpec anchors (superclass chains in test files) ── */
REG_TYPE("Minitest.Test");
REG_TYPE("ActiveSupport.TestCase");
REG_TYPE("ActionDispatch.IntegrationTest");
}
internal/cbm/lsp/py_lsp.c
+22 -1
View File
@@ -3249,7 +3249,28 @@ static void py_emit_call_for(PyLSPContext *ctx, TSNode call_node) {
py_emit_resolved_call_reason(ctx, qn, "lsp_import_alias", 0.85f, fname,
call_node);
} else if (qn && cbm_registry_lookup_type(ctx->registry, qn)) {
py_emit_resolved_call(ctx, qn, "lsp_constructor", 0.85f, call_node);
/* ClassName() binds to the __init__ the class declares
* itself. An inherited __init__ is not followed: B(A)
* without its own __init__ keeps the call on B, so a base
* constructor does not collect every subclass
* construction as its caller. Retarget only when this
* binding IS the class being called. An instance
* (`f = Foo(); f()`) keeps the class row: that call
* dispatches to __call__, and a reason-join would invent
* a Foo.__init__ edge. A builtins.* __init__ is not a
* project constructor, so the class target stays. */
const CBMRegisteredFunc *fi = NULL;
if (qn_short && strcmp(qn_short, fname) == 0) {
fi = cbm_registry_lookup_method(ctx->registry, qn, "__init__");
}
if (fi && fi->qualified_name &&
strncmp(fi->qualified_name, "builtins.", sizeof("builtins.") - 1) != 0) {
py_emit_resolved_call_reason(ctx, fi->qualified_name,
"lsp_constructor_init", 0.85f, fname,
call_node);
} else {
py_emit_resolved_call(ctx, qn, "lsp_constructor", 0.85f, call_node);
}
}
}
return;
internal/cbm/lsp/ruby_lsp.c
+1824
View File
File diff suppressed because it is too large. Load diff
internal/cbm/lsp/ruby_lsp.h
+176
View File
@@ -0,0 +1,176 @@
#ifndef CBM_LSP_RUBY_LSP_H
#define CBM_LSP_RUBY_LSP_H
#include "type_rep.h"
#include "scope.h"
#include "type_registry.h"
#include "../cbm.h"
/* Ruby mixin kinds. Lookup order for an instance method on class C:
* prepended modules (last prepended first) → C's own methods →
* included modules (last included first) → superclass chain.
* `extend` adds a module's instance methods to C's singleton (class-side). */
typedef enum {
RUBY_MIXIN_INCLUDE = 0,
RUBY_MIXIN_PREPEND,
RUBY_MIXIN_EXTEND,
} RubyMixinKind;
/* One class/module discovered in the file (or, cross-file, in the project).
* `path` is the dotted constant path used ONLY for constant lookup ("Admin.User"
* for both `module Admin; class User` and `class Admin::User`). `qn` is the
* graph QN built exactly the way the structural extractor builds it: each
* declaration's raw name text appended to the enclosing class QN (or the
* module QN at top level), so a compact `class Admin::User` yields
* "<module_qn>.Admin::User" while the lexically nested form yields
* "<module_qn>.Admin.User". Emitted rows must carry the extractor spelling
* or the pipeline's exact-name join silently drops them. `superclass_qn` is
* resolved against the class table + stdlib after collection; NULL when
* unknown. */
typedef struct {
const char *path;
const char *qn;
const char *superclass_ref; /* raw dotted superclass spelling, or NULL */
const char *superclass_qn; /* resolved QN (table/stdlib), or NULL */
bool is_module; /* `module` (mixin source) vs `class` */
/* Method-lookup visit marks: the stamp of the last walk that searched
* this class on the instance / singleton side (ruby_walk_seen). */
unsigned int seen_instance;
unsigned int seen_singleton;
} RubyClassInfo;
/* One `include`/`prepend`/`extend` record: owner class QN → module ref. */
typedef struct {
const char *owner_qn; /* class/module whose body held the call */
const char *module_ref; /* raw dotted module spelling */
const char *module_qn; /* resolved QN, or NULL */
RubyMixinKind kind;
} RubyMixinInfo;
/* One inferred instance-variable type: (class QN, @name) → type QN.
* `conflicted` latches when two assignments disagree — lookup then returns
* nothing (zero-edge guarantee beats a coin-flip type). */
typedef struct {
const char *class_qn;
const char *ivar_name; /* including the leading '@' */
const char *type_qn;
bool conflicted;
} RubyIvarInfo;
/* RubyLSPContext — per-file state for Ruby type-aware call resolution.
* Mirrors PerlLSPContext / PHPLSPContext structure.
*
* Ruby specifics that shape this context:
* - Classes/modules nest lexically (`module A; class B`), and constants
* resolve through the lexical nesting outward (A::B sees A's constants
* before top-level ones). `nesting` tracks the current dotted path.
* - Inheritance is `class C < Base`; mixins arrive via include/prepend/
* extend and participate in method lookup (see RubyMixinKind).
* - `Foo.new` constructs a Foo and dispatches to Foo#initialize.
* - `def m` defines an instance method; `def self.m` a singleton (class)
* method. Singleton methods are registered under the receiver key
* "<class_qn>.self" — constants cannot be lowercase, so the suffix can
* never collide with a real nested-constant path. */
typedef struct {
CBMArena *arena;
const char *source;
int source_len;
const CBMTypeRegistry *registry;
/* Mutable alias of `registry`, set only while PASS 1 populates method
* tables (mirrors perl_lsp's mutable-reg build phase). NULL afterwards. */
CBMTypeRegistry *build_reg;
CBMScope *current_scope;
/* Lexical nesting: one frame per enclosing class/module declaration,
* frames joined by '.', each frame keeping its raw source spelling ("" at
* top level, "M.A::B" inside `module M; class A::B`). Ruby's constant
* lookup walks the frames outward — inside `class A::B` the nesting is
* [A::B] only, so A's constants are NOT probed. */
const char *nesting;
/* Class/module table (pass 1). */
RubyClassInfo *classes;
int class_count;
int class_cap;
/* Mixin table (pass 1). */
RubyMixinInfo *mixins;
int mixin_count;
int mixin_cap;
/* Instance-variable type table (pass 1). */
RubyIvarInfo *ivars;
int ivar_count;
int ivar_cap;
/* Cross-file import map (require/require_relative resolved by the
* pipeline). Unused per-file: Ruby constants are file-global. */
const char **import_names;
const char **import_qns;
int import_count;
/* Current enclosing context during the resolution walk. */
const char *enclosing_class_qn; /* class QN, or NULL at top level */
const char *enclosing_func_qn; /* enclosing method QN, or NULL */
bool in_singleton_method; /* `def self.m` / class << self scope */
/* Inside a block that rebinds `self` (instance_eval/exec, class_eval/
* exec, module_eval/exec, define_method, Class.new/Module.new): the
* receiver of bare and `self.` calls is NOT the enclosing class, and
* the resolver cannot know what it is — so they emit nothing. */
bool self_unknown;
/* Number of enclosing blocks (`{ }`, `do end`, `-> { }`) since the
* nearest class/module body. A `def` met here is NOT a method of the
* enclosing class — ActiveSupport's `class_methods do … end`,
* `included do … end`, RSpec groups — so PASS 1 registers nothing for
* it and collects no mixins from it. */
int block_depth;
const char *module_qn;
/* Output: resolved calls accumulate here. */
CBMResolvedCallArray *resolved_calls;
/* Recursion guards. */
int eval_depth;
int walk_depth;
/* Stamp of the current method-lookup walk; each walk takes a fresh one
* so marks left by earlier walks never match. */
unsigned int lookup_stamp;
/* Debug mode (CBM_LSP_DEBUG env). */
bool debug;
} RubyLSPContext;
/* Initialize a RubyLSPContext for processing one file. */
void ruby_lsp_init(RubyLSPContext *ctx, CBMArena *arena, const char *source, int source_len,
const CBMTypeRegistry *registry, const char *module_qn,
CBMResolvedCallArray *out);
/* Resolve a dotted constant path (e.g. "Foo", "A.B") against the class
* table using the current lexical nesting, then the stdlib. Returns the
* resolved QN or NULL. */
const char *ruby_resolve_constant(RubyLSPContext *ctx, const char *path);
/* Look up an instance method on a class, walking prepends → own → includes →
* superclass chain. Returns the resolved CBMRegisteredFunc or NULL. */
const CBMRegisteredFunc *ruby_lookup_instance_method(RubyLSPContext *ctx, const char *class_qn,
const char *method_name);
/* Look up a singleton (class-side) method: own singleton methods →
* `extend`ed modules' instance methods → superclass singleton chain. */
const CBMRegisteredFunc *ruby_lookup_singleton_method(RubyLSPContext *ctx, const char *class_qn,
const char *method_name);
/* Evaluate a Ruby expression's type. May return CBM_TYPE_UNKNOWN. */
const CBMType *ruby_eval_expr_type(RubyLSPContext *ctx, TSNode node);
/* Entry point: build registry from file defs + stdlib, then run resolution.
* Called from cbm_extract_file() via the language dispatch in cbm.c. */
void cbm_run_ruby_lsp(CBMArena *arena, CBMFileResult *result, const char *source, int source_len,
TSNode root);
/* Register Ruby core stdlib types/methods + a curated Rails surface
* (ActiveRecord/ActiveSupport/ActionController) into a registry. */
void cbm_ruby_stdlib_register(CBMTypeRegistry *reg, CBMArena *arena);
#endif /* CBM_LSP_RUBY_LSP_H */
internal/cbm/lsp_all.c
+2
View File
@@ -14,6 +14,8 @@
#include "lsp/generated/php_stdlib_data.c"
#include "lsp/perl_lsp.c"
#include "lsp/generated/perl_stdlib_data.c"
#include "lsp/ruby_lsp.c"
#include "lsp/generated/ruby_stdlib_data.c"
#include "lsp/generated/python_stdlib_data.c"
#include "lsp/py_lsp.c"
#include "lsp/ts_lsp.c"
scripts/benchmark-index.sh
+107 -6
View File
@@ -9,11 +9,74 @@ LANG="${2:?}"
REPO="${3:?}"
RESULTS_DIR="${4:?}"
# Resolve symlinks
REPO=$(cd "$REPO" && pwd -P)
OUT="$RESULTS_DIR/$LANG"
mkdir -p "$OUT"
# A handoff names this run's index or none: the evaluation loop reuses the
# results directory, and a stale one would point the graph session at a root
# step 8 has already removed. It goes before any setup step that can fail, so
# a run that never reaches the index cannot leave an earlier one behind.
rm -f -- "$OUT/runtime-root.txt"
# The index must run against a daemon rendezvous and cache this run owns: only
# CBM_RUNTIME_DIR moves the rendezvous, and without a private cache the
# benchmark repository was indexed into the operator's live store (#1696).
# shellcheck source=test-runtime.sh
source "$(dirname "${BASH_SOURCE[0]}")/test-runtime.sh"
cbm_test_runtime_init
# The evaluation plan (docs/EVALUATION_PLAN.md §7) indexes a language here and
# then answers graph questions against that index from its own MCP session.
# A run-private root would be gone before that session starts, so the caller
# may ask for it to be kept: after a SUCCESSFUL run the harness stops its
# daemon, leaves the root in place, records the paths that reach it in
# <results>/<lang>/runtime-root.txt (sourceable), and ownership of the root —
# including its removal — passes to the caller. A failed run cleans up
# regardless: there is no index worth keeping, and nothing must leak. Never on
# by default, or an unattended run accumulates one root per language.
#
# The handoff promises a stopped daemon, so it is written only once
# `daemon stop` succeeded. A refused stop (a client still committed to the
# daemon, or no answer) fails the run with the product's explanation, writes
# no handoff, and keeps the root without cleaning it up: the daemon may still
# be using it, and the operator decides what happens to it.
bench_finish() {
local rc=$? stop_out=""
[ -z "${BENCH_TMP:-}" ] || rm -rf -- "$BENCH_TMP" || true
if [ "$rc" -eq 0 ] && [ -n "${CBM_BENCH_KEEP_RUNTIME:-}" ] && [ -d "${OUT:-}" ]; then
if ! stop_out=$("$BINARY" daemon stop 2>&1); then
echo " $LANG: private daemon did not stop; runtime kept at $CBM_TEST_RUNTIME_ROOT, no handoff written" >&2
[ -z "$stop_out" ] || printf '%s\n' "$stop_out" >&2
exit 1
fi
printf 'CBM_BENCH_RUNTIME_ROOT=%q\nCBM_RUNTIME_DIR=%q\nCBM_CACHE_DIR=%q\n' \
"$CBM_TEST_RUNTIME_ROOT" "$CBM_RUNTIME_DIR" "$CBM_CACHE_DIR" > "$OUT/runtime-root.txt"
echo " $LANG: runtime kept at $CBM_TEST_RUNTIME_ROOT; paths in $OUT/runtime-root.txt" >&2
return 0
fi
cbm_test_runtime_cleanup "$BINARY"
}
BENCH_TMP=""
trap bench_finish EXIT
# The index call keeps its stderr, the way the search-graph twin does: for a
# one-shot CLI that is the only channel a refusal is reported on, and without
# it the failure below could name only its symptom.
BENCH_TMP=$(mktemp -d)
INDEX_ERR="$BENCH_TMP/index-stderr.log"
DAEMON_START_LOG="$BENCH_TMP/daemon-start.log"
# Resolve symlinks
REPO=$(cd "$REPO" && pwd -P)
# One pre-escaped spelling of the path for every request below, the way the
# soak harness builds its own: a repository path may legitimately contain a
# quote or a backslash, and hand-built JSON turns that into a parse error.
REPO_JSON=$(python3 -c 'import json,sys; print(json.dumps(sys.argv[1]))' "$REPO")
# Elapsed time is read from a monotonic clock, never the wall clock: an NTP
# step mid-run would otherwise skew — or negate — a figure whose whole purpose
# is comparison across runs. Its reference point is fixed per boot on every
# platform CPython supports here, so the three readings below are comparable
# even though each comes from its own process.
bench_now_ms() { python3 -c "import time; print(time.monotonic_ns() // 1000000)"; }
echo "INDEX: $LANG ($REPO)"
@@ -33,16 +96,39 @@ LOC=$(find "$REPO" -type f \
echo "$FILE_COUNT" > "$OUT/file-count.txt"
echo "$LOC" > "$OUT/loc.txt"
# Start the private daemon before timing so index-time.txt measures the index
# alone. setup-time.txt keeps the activation cost attributable and
# total-time.txt is their sum — the figure comparable with earlier runs, which
# paid activation inside the index timing whenever no daemon was already warm.
SETUP_START_MS=$(bench_now_ms)
# Its output is kept for the failure path: the product names why a daemon did
# not start, and that is the part an operator needs.
if ! "$BINARY" daemon start >"$DAEMON_START_LOG" 2>&1; then
echo " $LANG: private daemon did not start" >&2
if [ -s "$DAEMON_START_LOG" ]; then
echo "--- daemon start output ---" >&2
cat "$DAEMON_START_LOG" >&2
fi
exit 1
fi
# Index via CLI and capture timing
START_MS=$(python3 -c "import time; print(int(time.time()*1000))")
START_MS=$(bench_now_ms)
INDEX_JSON=$("$BINARY" cli index_repository "{\"repo_path\":\"$REPO\",\"mode\":\"full\"}" 2>/dev/null || echo '{"error":"index failed"}')
# The CLI's exit status is the index's verdict. It is recorded here and acted
# on below, once every per-run file is written; an empty response stays valid
# JSON in 00-index.json so the failure is legible there as well.
INDEX_RC=0
INDEX_JSON=$("$BINARY" cli index_repository "{\"repo_path\":$REPO_JSON,\"mode\":\"full\"}" 2>"$INDEX_ERR") ||
{ INDEX_RC=$?; INDEX_JSON="{\"error\":\"index failed\",\"exit\":$INDEX_RC}"; }
END_MS=$(python3 -c "import time; print(int(time.time()*1000))")
END_MS=$(bench_now_ms)
ELAPSED=$((END_MS - START_MS))
echo "$INDEX_JSON" > "$OUT/00-index.json"
echo "$ELAPSED" > "$OUT/index-time.txt"
echo "$((START_MS - SETUP_START_MS))" > "$OUT/setup-time.txt"
echo "$((END_MS - SETUP_START_MS))" > "$OUT/total-time.txt"
# Extract node/edge counts (CLI wraps in MCP content envelope)
NODES=$(echo "$INDEX_JSON" | python3 -c "
@@ -78,5 +164,20 @@ echo "$NODES" > "$OUT/nodes.txt"
echo "$EDGES" > "$OUT/edges.txt"
echo "$PROJECT" > "$OUT/project.txt"
# An index that failed, or that named no project, fails the run: after the
# timing files, so the caller keeps its figures, and through the exit status,
# so the caller's loop notices and bench_finish never keeps a root with no
# index in it.
if [ "$INDEX_RC" -ne 0 ] || [ -z "$PROJECT" ]; then
echo " $LANG: index failed (cli exit $INDEX_RC, project '$PROJECT'); response in $OUT/00-index.json" >&2
if [ -s "$INDEX_ERR" ]; then
echo "--- index stderr ---" >&2
cat "$INDEX_ERR" >&2
fi
echo "--- index response (first 500 bytes) ---" >&2
printf '%.500s\n' "$INDEX_JSON" >&2
exit 1
fi
printf " %s: %s files, %s LOC, %sms, %s nodes, %s edges\n" \
"$LANG" "$FILE_COUNT" "$LOC" "$ELAPSED" "$NODES" "$EDGES"
scripts/benchmark-search-graph.sh
+59 -5
View File
@@ -3,18 +3,72 @@
# codebase-memory-mcp binary to measure the regex / LIKE pre-filter performance.
#
# Usage:
# scripts/benchmark-search-graph.sh <binary-path> <project-name>
# scripts/benchmark-search-graph.sh <binary-path> <repo-path>
#
# Example:
# scripts/benchmark-search-graph.sh ./build/c/codebase-memory-mcp my-project
# scripts/benchmark-search-graph.sh ./build/c/codebase-memory-mcp ~/src/my-project
#
# The repository is indexed (untimed) into a private runtime and cache first;
# the queries then run against that index through a daemon this run keeps warm,
# so a timing never includes daemon activation and never touches the operator's
# live store (#1696).
set -euo pipefail
BINARY="${1:?Usage: $0 <binary-path> <project-name>}"
PROJECT="${2:?Usage: $0 <binary-path> <project-name>}"
BINARY="${1:?Usage: $0 <binary-path> <repo-path>}"
REPO="${2:?Usage: $0 <binary-path> <repo-path>}"
REPO=$(cd "$REPO" && pwd -P)
# shellcheck source=test-runtime.sh
source "$(dirname "${BASH_SOURCE[0]}")/test-runtime.sh"
cbm_test_runtime_init
BENCH_TMP=""
trap 'cbm_test_runtime_cleanup "$BINARY"; [ -z "$BENCH_TMP" ] || rm -rf -- "$BENCH_TMP"' EXIT
BENCH_TMP=$(mktemp -d)
INDEX_ERR="$BENCH_TMP/index-stderr.log"
DAEMON_START_LOG="$BENCH_TMP/daemon-start.log"
# Its output is kept for the failure path: the product names why a daemon did
# not start, and that is the part an operator needs.
if ! "$BINARY" daemon start >"$DAEMON_START_LOG" 2>&1; then
echo "private daemon did not start" >&2
if [ -s "$DAEMON_START_LOG" ]; then
echo "--- daemon start output ---" >&2
cat "$DAEMON_START_LOG" >&2
fi
exit 1
fi
# One pre-escaped spelling of the path, the way the soak harness builds its
# own: a repository path may legitimately contain a quote or a backslash, and
# hand-built JSON turns that into a parse error.
REPO_JSON=$(python3 -c 'import json,sys; print(json.dumps(sys.argv[1]))' "$REPO")
# Index and parse keep their stderr instead of discarding it: without it the
# failure below names only its symptom, and the cause — an unreadable
# repository, a refused daemon, a malformed envelope — is unrecoverable.
INDEX_JSON=$("$BINARY" cli index_repository "{\"repo_path\":$REPO_JSON,\"mode\":\"full\"}" \
2>"$INDEX_ERR" || echo '{}')
PROJECT=$(echo "$INDEX_JSON" | python3 -c "
import json, sys
d = json.load(sys.stdin)
if 'content' in d:
d = json.loads(d['content'][0]['text'])
print(d.get('project', ''))
" 2>>"$INDEX_ERR" || echo "")
if [ -z "$PROJECT" ]; then
echo "index of $REPO did not report a project" >&2
if [ -s "$INDEX_ERR" ]; then
echo "--- index/parse stderr ---" >&2
cat "$INDEX_ERR" >&2
fi
if [ -n "$INDEX_JSON" ]; then
echo "--- index response (first 500 bytes) ---" >&2
printf '%.500s\n' "$INDEX_JSON" >&2
fi
exit 1
fi
echo "Binary: $BINARY"
echo "Project: $PROJECT"
echo "Project: $PROJECT (indexed from $REPO)"
echo ""
run_case() {
scripts/check-lsp-originality.sh
+5 -1
View File
@@ -27,7 +27,7 @@
# USAGE
# bash scripts/check-lsp-originality.sh [--lang NAME] [--refresh]
# [--list-candidates] [--help]
# --lang NAME scan against ONE reference only (py|ts|go|cs|c|java|kotlin|rust|php|perl)
# --lang NAME scan against ONE reference only (py|ts|go|cs|c|java|kotlin|rust|php|perl|ruby)
# --refresh re-fetch reference sources even if cached
# --list-candidates print the extracted local tokens and exit (no fetch; self-test)
# Exit 0 = no verbatim overlap found. Exit 1 = overlap(s) to review by a human.
@@ -64,6 +64,10 @@ REFS=(
# Perl (PR #461) was authored clean-room. We scan against PerlNavigator (MIT)
# — the leading OSS Perl language server — for defensive copy-detection.
"perl|https://github.com/bscan/PerlNavigator|server/src"
# Ruby was authored clean-room from the tree-sitter-ruby grammar + Ruby
# language semantics. We scan against Shopify's ruby-lsp (MIT) — the
# leading OSS Ruby language server — for defensive copy-detection.
"ruby|https://github.com/Shopify/ruby-lsp|lib"
# Infrastructure hybrid LSPs (K8s YAML, Kustomize bundles, Flux/Argo deploy
# scopes, the Go operator extension) were written from the Kubernetes, Flux,
# Argo, Cluster API, cert-manager and Kubermatic API types. Scanned against
scripts/test.sh
+6
View File
@@ -316,6 +316,9 @@ bash "$ROOT/tests/test_parallel_harness_contract.sh"
echo "=== Step 0i2: suite failure-report contract ==="
bash "$ROOT/tests/test_failure_report_contract.sh"
echo "=== Step 0i3: benchmark harness runtime isolation contract (#1696) ==="
bash "$ROOT/tests/test_benchmark_runtime_isolation_contract.sh"
echo "=== Step 0j: venue parity contract (one harness, every venue) ==="
bash "$ROOT/tests/test_venue_parity_contract.sh"
@@ -364,6 +367,9 @@ bash "$ROOT/tests/test_language_count_contract.sh"
echo "=== Step 0x: packaging version-metadata contract ==="
bash "$ROOT/tests/test_version_metadata_contract.sh"
echo "=== Step 0x2: installer Android/Termux guard contract (#1202) ==="
bash "$ROOT/tests/test_install_android_guard.sh"
# Step 0y: the Windows leg must not decide its verdict from an exit status that
# the ssh/msys2_shell chain can mangle — a channel that turns 0 into 1 can turn
# 1 into 0, and that direction reports a RED Windows leg as green. Runs
src/cli/cli.c
+1
View File
@@ -8088,6 +8088,7 @@ static const config_key_def_t CONFIG_KEYS[] = {
{CBM_CONFIG_AUTO_INDEX, "false", "Enable auto-indexing on MCP session start"},
{CBM_CONFIG_AUTO_INDEX_LIMIT, "50000", "Max files for auto-indexing new projects"},
{CBM_CONFIG_AUTO_WATCH, "true", "Register background git watcher on session connect"},
{CBM_CONFIG_IGNORE_WORKTREES, "false", "Skip linked git worktrees when indexing automatically"},
/* Unset: the index mode decides (cbm_pipeline_doc_candidates_enabled). */
{CBM_CONFIG_DOC_CANDIDATES, "auto",
"Doc-code candidates: auto = on for full, off for moderate/fast; true/false forces"},
src/cli/cli.h
+6 -1
View File
@@ -336,7 +336,11 @@ bool cbm_hook_augment_invocation_supported_for_testing(const char *dialect,
const char *forced_event);
bool cbm_hook_path_contains_for_testing(const char *root, const char *candidate,
bool case_insensitive);
const char *cbm_hook_no_project_index_guidance_for_testing(const char *event);
const char *cbm_hook_no_project_index_guidance_for_testing(const char *event,
bool worktree_ignored);
/* Counts lifecycle calls that reached the ignore_worktrees resolution (cwd
* canonicalization and the linked-worktree probe). NULL stops counting. */
void cbm_hook_set_worktree_gate_counter_for_testing(int *counter);
bool cbm_hook_augment_parse_bash_pattern_for_testing(const char *cmd, char *out, size_t out_sz);
/* include_posttool false renders the previous lifecycle-only manifest. Release
* the result with cbm_free(CBM_MEM_CLASS_OTHER, ...). */
@@ -526,6 +530,7 @@ bool cbm_config_load_index_policy(cbm_config_t *cfg, cbm_index_resource_policy_t
#define CBM_CONFIG_AUTO_INDEX "auto_index"
#define CBM_CONFIG_AUTO_INDEX_LIMIT "auto_index_limit"
#define CBM_CONFIG_AUTO_WATCH "auto_watch"
#define CBM_CONFIG_IGNORE_WORKTREES "ignore_worktrees"
#define CBM_CONFIG_DOC_CANDIDATES "doc_candidates"
#define CBM_CONFIG_UI_LANG "ui-lang"
#define CBM_CONFIG_WATCHER_ENABLED "watcher_enabled"
src/cli/hook_augment.c
+69 -6
View File
@@ -17,11 +17,14 @@
*/
#include "cli/cli.h"
#include "foundation/compat.h"
#include "foundation/compat_fs.h"
#include "foundation/constants.h"
#include "foundation/mem.h"
#include "foundation/platform.h"
#include "git/git_context.h"
#include "mcp/mcp.h"
#include "mcp/mcp_internal.h"
#include "pipeline/pipeline.h"
#include "yyjson/yyjson.h"
@@ -1654,7 +1657,14 @@ static const char *ha_active_tier(yyjson_val *root, const char *event) {
return "Tier 2 verification";
}
static const char *ha_no_project_index_guidance(const char *event) {
static const char *ha_no_project_index_guidance(const char *event, bool worktree_ignored) {
/* ignore_worktrees is on and this cwd is a linked worktree: indexing it is
* deliberately disabled, so telling the agent to run index_repository would
* only produce a refusal. Point at the setting instead. */
if (worktree_ignored) {
return "This is a linked git worktree and ignore_worktrees is enabled, so it is not "
"indexed on purpose; do not run index_repository here.";
}
return event && strcmp(event, "SubagentStart") == 0
? "Ask the parent agent to run index_repository before structural exploration; "
"do not attempt graph mutation."
@@ -1671,6 +1681,41 @@ static bool ha_invocation_supported(ha_lifecycle_dialect_t dialect, const char *
return !forced_event || ha_dialect_event_supported(dialect, forced_event);
}
#ifdef CBM_CLI_ENABLE_TEST_API
static CBM_TLS int *g_ha_worktree_gate_counter = NULL;
#endif
/* Project resolution once ignore_worktrees is on; the caller runs this only
* after reading the key, so the default path does none of it. A symlink alias
* has no .git of its own, and walking its lexical parents leaves the linked
* worktree. index_repository canonicalizes before the same gate, so the hook
* must too or it tells the agent to index a path the setting will refuse. The
* setting refuses a linked worktree even when it sits inside an indexed
* checkout or inside another linked worktree, so a match is kept only when its
* root belongs to this cwd's own linked worktree, not a parent graph. */
static char *ha_resolve_project_ignoring_worktrees(cbm_mcp_server_t *srv, const char *cwd,
bool *drop_ancestor, bool *worktree_ignored) {
#ifdef CBM_CLI_ENABLE_TEST_API
if (g_ha_worktree_gate_counter) {
(*g_ha_worktree_gate_counter)++;
}
#endif
char canonical_cwd[4096];
if (ha_canonical_path(cwd, canonical_cwd, sizeof(canonical_cwd))) {
cwd = canonical_cwd;
}
char project_root[4096];
project_root[0] = '\0';
char *project =
ha_resolve_indexed_project_with_root(srv, cwd, project_root, sizeof(project_root));
bool linked = cbm_git_is_linked_worktree(cwd);
/* Drop a parent graph without a second free(): this file's raw free count
* is ratcheted, and the caller's single free(project) still releases it. */
*drop_ancestor = linked && project && !cbm_git_same_linked_worktree(cwd, project_root);
*worktree_ignored = linked && (!project || *drop_ancestor);
return project;
}
static char *ha_lifecycle_json_from_root(cbm_mcp_server_t *srv, yyjson_val *root,
const char *forced_event, ha_lifecycle_dialect_t dialect) {
if (!root || !yyjson_is_obj(root)) {
@@ -1688,7 +1733,20 @@ static char *ha_lifecycle_json_from_root(cbm_mcp_server_t *srv, yyjson_val *root
srv = owned_server;
}
const char *cwd = ha_normalized_cwd_with_server(root, srv, cwd_buffer, sizeof(cwd_buffer));
char *project = srv && cwd ? ha_resolve_indexed_project(srv, cwd) : NULL;
/* Read ignore_worktrees first and do nothing else for it while it is off.
* cbm_mcp_server_new(NULL) has no store, and srv may be the daemon's
* session server, so the read leaves srv untouched (see
* cbm_mcp_ignore_worktrees_runtime_enabled). Off, this is the resolution
* the hook did before the key existed. */
bool drop_ancestor = false;
bool worktree_ignored = false;
char *project = NULL;
if (srv && cwd && cbm_mcp_ignore_worktrees_runtime_enabled(srv)) {
project =
ha_resolve_project_ignoring_worktrees(srv, cwd, &drop_ancestor, &worktree_ignored);
} else {
project = srv && cwd ? ha_resolve_indexed_project(srv, cwd) : NULL;
}
cbm_mcp_server_free(owned_server);
char context[2048];
@@ -1713,7 +1771,7 @@ static char *ha_lifecycle_json_from_root(cbm_mcp_server_t *srv, yyjson_val *root
? " The same tools are also available from the shell: "
"`codebase-memory-mcp cli <tool> --help` lists each tool's flags."
: "";
if (project) {
if (project && !drop_ancestor) {
char safe_project[HA_METADATA_CAP];
ha_sanitize_metadata(project, safe_project, sizeof(safe_project));
/* The untrusted label covers the graph-derived project name only. Wrapping
@@ -1732,7 +1790,7 @@ static char *ha_lifecycle_json_from_root(cbm_mcp_server_t *srv, yyjson_val *root
"and file reads for literals, configs, non-code files, and verification.%s",
scope, safe_project, tier, cli_hint);
} else {
const char *index_guidance = ha_no_project_index_guidance(event);
const char *index_guidance = ha_no_project_index_guidance(event, worktree_ignored);
snprintf(context, sizeof(context),
"[codebase-memory] %s context: no indexed graph project matched this working "
"directory. %s Once indexed, "
@@ -1851,8 +1909,13 @@ bool cbm_hook_path_contains_for_testing(const char *root, const char *candidate,
return ha_path_contains_mode(root, candidate, case_insensitive);
}
const char *cbm_hook_no_project_index_guidance_for_testing(const char *event) {
return ha_no_project_index_guidance(event);
const char *cbm_hook_no_project_index_guidance_for_testing(const char *event,
bool worktree_ignored) {
return ha_no_project_index_guidance(event, worktree_ignored);
}
void cbm_hook_set_worktree_gate_counter_for_testing(int *counter) {
g_ha_worktree_gate_counter = counter;
}
bool cbm_hook_augment_parse_bash_pattern_for_testing(const char *cmd, char *out, size_t out_sz) {
src/daemon/application.c
+18
View File
@@ -17,6 +17,7 @@
#include "foundation/sha256.h"
#include "foundation/subprocess.h"
#include "foundation/workspace.h"
#include "git/git_context.h"
#include "mcp/index_supervisor.h"
#include "mcp/mcp.h"
#include "mcp/mcp_internal.h"
@@ -1941,6 +1942,18 @@ static void application_auto_index_retry_pending_locked(cbm_daemon_application_t
application_refresh_watch_locked(session);
continue;
}
/* ignore_worktrees can be turned on after this session was queued for
* a capacity slot. Initial admission already skips linked worktrees;
* retry must apply the same gate or the pending checkout is indexed
* once a slot opens. */
if (cbm_mcp_ignore_worktrees_enabled(session->mcp) &&
cbm_git_is_linked_worktree(root_path)) {
session->auto_index_retry_pending = false;
cbm_log_info("daemon.autoindex.skipped", "project", project, "reason",
"linked_worktree");
application_refresh_watch_locked(session);
continue;
}
char *args = application_auto_index_args(application, root_path);
if (!args) {
continue;
@@ -2599,6 +2612,11 @@ static void application_background_initialize_impl(cbm_daemon_application_sessio
!application_session_workspace_allowed(session, "auto_index_discovery")) {
auto_index_candidate = false;
}
if (auto_index_candidate && cbm_mcp_ignore_worktrees_enabled(session->mcp) &&
cbm_git_is_linked_worktree(root_path)) {
cbm_log_info("daemon.autoindex.skipped", "project", project, "reason", "linked_worktree");
auto_index_candidate = false;
}
bool within_auto_index_limit =
!auto_index_candidate ||
cbm_mcp_auto_index_within_file_limit(root_path, auto_index_limit, &tracked_files);
src/daemon/ipc.c
+23 -9
View File
@@ -1263,6 +1263,13 @@ static int posix_named_shared_lock_try_acquire(const cbm_daemon_ipc_endpoint_t *
return posix_named_lock_try_acquire_mode(endpoint, lock_name, true, fd_out, process_entry_out);
}
/* Never open and close the lifetime lock file in a process that may already
* hold it: fcntl(2) record locks are scoped to (process, inode), so that
* close would silently release every lock this process holds on the file,
* regardless of which fd took it. This lock is fcntl rather than flock for
* exactly this reason in reverse: flock locks survive a fork, fcntl locks
* do not, and a forked child must never appear to hold its parent's
* reservation. */
static int posix_record_lock_set(int fd, short lock_type) {
struct flock record_lock = {
.l_type = lock_type,
@@ -1286,6 +1293,15 @@ static int posix_lifetime_lock_probe(const cbm_daemon_ipc_endpoint_t *endpoint,
if (process_claimed < 0) {
return -1;
}
if (process_claimed == 1) {
/* Already held by this process per the in-process registry: trust
* that alone. Opening a throwaway fd on the lock file here and then
* closing it would release the real fcntl(2) record lock, which is
* scoped to (process, inode) rather than (fd, inode): closing any
* fd on this inode drops every lock this process holds on it, even
* one held via a different, still-open fd. */
return endpoint_runtime_still_valid(endpoint) ? 1 : -1;
}
int fd = openat(endpoint->dir_fd, lock_name, O_RDWR | O_CLOEXEC | O_NOFOLLOW);
if (fd < 0) {
@@ -1297,10 +1313,6 @@ static int posix_lifetime_lock_probe(const cbm_daemon_ipc_endpoint_t *endpoint,
(void)close(fd);
return -1;
}
if (process_claimed == 1) {
bool still_private = endpoint_runtime_still_valid(endpoint);
return close(fd) == 0 && still_private ? 1 : -1;
}
struct flock record_lock = {
.l_type = F_WRLCK,
.l_whence = SEEK_SET,
@@ -1338,11 +1350,13 @@ static int posix_lifetime_lock_try_acquire(const cbm_daemon_ipc_endpoint_t *endp
process_lock_entry_t *process_entry = NULL;
int process_result = process_lock_claim(endpoint, lock_name, &process_entry);
if (process_result != 1) {
return process_result == 0 &&
private_regular_file_at_is_safe(endpoint->dir_fd, lock_name, 1) &&
endpoint_runtime_still_valid(endpoint)
? 0
: -1;
/* Already held by this process per the in-process registry: trust
* that alone, the same as the probe's early return above. Calling
* private_regular_file_at_is_safe() here would open a throwaway fd
* on the lock file and close it, releasing the real fcntl(2) record
* lock this process holds, because that lock is scoped to (process,
* inode) rather than (fd, inode). */
return process_result == 0 && endpoint_runtime_still_valid(endpoint) ? 0 : -1;
}
int fd = openat(endpoint->dir_fd, lock_name, O_RDWR | O_CREAT | O_CLOEXEC | O_NOFOLLOW, 0600);
if (fd < 0 || !fd_set_cloexec(fd)) {
src/foundation/platform.c
+25
View File
@@ -729,3 +729,28 @@ const char *cbm_resolve_cache_dir(void) {
}
return buf;
}
/* ── CPU scheduling priority ────────────────── */
#ifndef _WIN32
#include <sys/resource.h>
#endif
bool cbm_lower_cpu_priority(void) {
#ifdef _WIN32
HANDLE self = GetCurrentProcess();
DWORD current = GetPriorityClass(self);
if (current == IDLE_PRIORITY_CLASS || current == BELOW_NORMAL_PRIORITY_CLASS) {
return true; /* already at least this low: never raise priority */
}
return SetPriorityClass(self, BELOW_NORMAL_PRIORITY_CLASS) != 0;
#else
/* getpriority can legitimately return -1, so errno is the only error signal. */
errno = 0;
int current = getpriority(PRIO_PROCESS, 0);
if (errno == 0 && current >= CBM_LOW_CPU_PRIORITY_NICE) {
return true; /* already at least this nice: never raise priority */
}
return setpriority(PRIO_PROCESS, 0, CBM_LOW_CPU_PRIORITY_NICE) == 0;
#endif
}
src/foundation/platform.h
+13
View File
@@ -215,4 +215,17 @@ int64_t cbm_file_size(const char *path);
* On POSIX, this is a no-op. Returns the input pointer. */
char *cbm_normalize_path_sep(char *path);
/* ── CPU scheduling priority ───────────────────────────────────── */
enum { CBM_LOW_CPU_PRIORITY_NICE = 10 };
/* Lower this process's CPU scheduling priority so background work yields the
* cores to interactive processes. POSIX: nice CBM_LOW_CPU_PRIORITY_NICE (never
* raises an already-nicer process). Plain nice only, deliberately not macOS
* background QoS: that pins work to efficiency cores and throttles I/O.
* Windows: BELOW_NORMAL_PRIORITY_CLASS. On Linux nice is per thread, so call
* this before creating threads; later threads inherit it.
* Returns false when the priority could not be changed. */
bool cbm_lower_cpu_priority(void);
#endif /* CBM_PLATFORM_H */
src/git/git_context.c
+403
View File
@@ -3,6 +3,7 @@
#include "foundation/compat_fs.h"
#include "foundation/constants.h"
#include "foundation/log.h"
#include "foundation/mem_core.h"
#include "foundation/platform.h"
#include "foundation/str_util.h"
@@ -17,6 +18,17 @@ enum {
GIT_OUTPUT_MAX = 4096,
};
/* Bounded worktree-status stream constants.
* STATUS_FIELD_MAX is the largest single NUL-delimited record field we
* buffer; a field at/over the bound is treated as a malformed stream and the
* whole snapshot fails closed. PATH components of real repos are far below
* this even with long paths. */
enum {
STATUS_HEADER_LEN = 3, /* porcelain-v1 record prefix "XY " */
STATUS_CHUNK_MAX = CBM_SZ_4K,
STATUS_FIELD_MAX = CBM_SZ_16K,
};
static char *git_strdup(const char *s) {
if (!s) {
s = "";
@@ -73,6 +85,8 @@ static int git_capture_into(const char *repo_path, const char *git_args, char *b
* stuck git child is named by the last marker printed (spawn, read or
* close). Silent at the default level. */
cbm_log_debug("git.capture", "stage", "spawn", "args", git_args);
/* A hook or editor may export GIT_DIR/GIT_WORK_TREE for another repo.
* Isolate this child so git -C selects repo_path rather than that repo. */
FILE *fp = cbm_popen_git(cmd);
if (!fp) {
return CBM_NOT_FOUND;
@@ -111,6 +125,14 @@ static int git_capture(const char *repo_path, const char *git_args, char **out)
return *out ? 0 : CBM_NOT_FOUND;
}
/* Regular file, not a directory and not a symlink. Uses the Unicode-safe
* path probe: stat() follows links and rejects non-ASCII paths on Windows,
* which upstream removed from this file in the Unicode repository-path fix. */
static bool path_is_regular_file(const char *path) {
cbm_path_info_t info;
return cbm_path_info_utf8(path, &info) == CBM_PATH_INFO_OK && info.is_regular;
}
static bool path_is_absolute(const char *path) {
if (!path || !path[0]) {
return false;
@@ -125,6 +147,180 @@ static bool path_is_absolute(const char *path) {
#endif
}
/* Read the "gitdir: <path>" pointer out of a gitlink FILE at <path>/.git.
* Returns false when .git is missing, a directory (ordinary repo), or holds no
* pointer. A relative pointer is resolved against path. */
static bool read_gitlink_target(const char *path, char *out, size_t out_size) {
char dot_git[GIT_OUTPUT_MAX];
int n = snprintf(dot_git, sizeof(dot_git), "%s/.git", path);
if (n < 0 || n >= (int)sizeof(dot_git)) {
return false;
}
if (!path_is_regular_file(dot_git)) {
return false;
}
FILE *f = cbm_fopen(dot_git, "r");
if (!f) {
return false;
}
char line[GIT_OUTPUT_MAX];
bool got = false;
while (fgets(line, sizeof(line), f)) {
trim_newlines(line);
if (strncmp(line, "gitdir:", 7) != 0) {
continue;
}
const char *value = line + 7;
while (*value == ' ' || *value == '\t') {
value++;
}
if (!value[0]) {
break;
}
int written = path_is_absolute(value) ? snprintf(out, out_size, "%s", value)
: snprintf(out, out_size, "%s/%s", path, value);
got = written > 0 && written < (int)out_size;
break;
}
fclose(f);
return got;
}
/* 1 = linked-worktree gitlink, 0 = a different git anchor (stop walking),
* -1 = no .git at this directory (keep walking). */
static int linked_worktree_anchor(const char *path) {
char dot_git[GIT_OUTPUT_MAX];
int n = snprintf(dot_git, sizeof(dot_git), "%s/.git", path);
if (n < 0 || n >= (int)sizeof(dot_git)) {
return 0;
}
cbm_path_info_t info;
if (cbm_path_info_utf8(dot_git, &info) != CBM_PATH_INFO_OK) {
return -1;
}
/* A directory .git is a main checkout. Anything else that is not a
* regular gitlink file (a symlink, for example) is also an anchor:
* do not follow it, and do not blame a parent worktree for this tree. */
if (!info.is_regular) {
return 0;
}
char git_dir[GIT_OUTPUT_MAX];
if (!read_gitlink_target(path, git_dir, sizeof(git_dir))) {
return 0;
}
/* Only linked worktrees carry <gitdir>/commondir; a submodule gitlink
* points at <super>/.git/modules/<name>, which does not. */
char commondir[GIT_OUTPUT_MAX];
n = snprintf(commondir, sizeof(commondir), "%s/commondir", git_dir);
if (n < 0 || n >= (int)sizeof(commondir)) {
return 0;
}
return path_is_regular_file(commondir) ? 1 : 0;
}
static bool parent_directory(char *path) {
size_t n = strlen(path);
while (n > 1 && (path[n - 1] == '/' || path[n - 1] == '\\')) {
path[--n] = '\0';
}
#ifdef _WIN32
if ((n == 2 && path[1] == ':') ||
(n == 3 && path[1] == ':' && (path[2] == '/' || path[2] == '\\'))) {
return false;
}
#endif
if (n <= 1) {
return false;
}
char *slash = NULL;
for (size_t i = 0; i < n; i++) {
if (path[i] == '/' || path[i] == '\\') {
slash = path + i;
}
}
if (!slash) {
return false;
}
if (slash == path) {
path[1] = '\0';
return true;
}
*slash = '\0';
return true;
}
/* On a linked-worktree hit, optionally copy that anchor directory into root_out. */
static bool walk_linked_worktree_root(const char *path, char *root_out, size_t root_out_size) {
if (!path || !path[0]) {
return false;
}
char current[GIT_OUTPUT_MAX];
int n = snprintf(current, sizeof(current), "%s", path);
if (n < 0 || n >= (int)sizeof(current)) {
return false;
}
size_t len = strlen(current);
while (len > 1 && (current[len - 1] == '/' || current[len - 1] == '\\')) {
current[--len] = '\0';
}
/* A session cwd or index_repository path is often a subdirectory. Walk
* ancestors until a git anchor so ignore_worktrees applies to the whole
* linked checkout, not only its root. */
/* Bound is the path itself: each step drops one component and stops at
* the filesystem root. A fixed depth would miss a deep session cwd. */
for (;;) {
int kind = linked_worktree_anchor(current);
if (kind >= 0) {
if (kind != 1) {
return false;
}
if (root_out && root_out_size > 0U) {
int written = snprintf(root_out, root_out_size, "%s", current);
if (written < 0 || (size_t)written >= root_out_size) {
return false;
}
}
return true;
}
char previous[GIT_OUTPUT_MAX];
snprintf(previous, sizeof(previous), "%s", current);
if (!parent_directory(current) || strcmp(previous, current) == 0) {
return false;
}
}
}
bool cbm_git_is_linked_worktree(const char *path) {
return walk_linked_worktree_root(path, NULL, 0U);
}
bool cbm_git_same_linked_worktree(const char *a, const char *b) {
char root_a[GIT_OUTPUT_MAX];
char root_b[GIT_OUTPUT_MAX];
if (!walk_linked_worktree_root(a, root_a, sizeof(root_a)) ||
!walk_linked_worktree_root(b, root_b, sizeof(root_b))) {
return false;
}
/* The gitdir file is unique per linked worktree. Comparing those pointers
* keeps a nested worktree from matching its parent even when both are
* linked checkouts. */
char git_a[GIT_OUTPUT_MAX];
char git_b[GIT_OUTPUT_MAX];
if (!read_gitlink_target(root_a, git_a, sizeof(git_a)) ||
!read_gitlink_target(root_b, git_b, sizeof(git_b))) {
return false;
}
/* A relative gitdir is joined onto the walked path. Canonicalize both so
* a symlink spelling of the cwd still matches the real project root.
* Fall back to the raw string when the gitdir does not exist. */
char norm_a[GIT_OUTPUT_MAX];
char norm_b[GIT_OUTPUT_MAX];
const char *left = cbm_canonical_path(git_a, norm_a, sizeof(norm_a)) ? norm_a : git_a;
const char *right = cbm_canonical_path(git_b, norm_b, sizeof(norm_b)) ? norm_b : git_b;
return strcmp(left, right) == 0;
}
static char *join_root_relative(const char *root, const char *rel) {
if (!root || !root[0]) {
return git_strdup(rel);
@@ -457,3 +653,210 @@ int cbm_git_context_props_json(const cbm_git_context_t *ctx, char *buf, int buf_
}
return off;
}
/* ── Bounded worktree status ──────────────────────────────────────────────
* git status --porcelain=v1 -z --untracked-files=all is parsed record by
* record, NUL-delimited, over a bounded chunk buffer. The full stream is
* counted but only max_samples paths per class (tracked / untracked) are
* ever retained, so a huge dirty tree cannot grow memory. Rename/copy
* records carry a second NUL-terminated path (the source); it is consumed
* without being counted so one rename counts once. */
typedef struct {
cbm_worktree_status_t *out;
int max_samples;
bool expecting_source; /* next field is the source path of an R/C record */
bool parse_ok;
char partial[STATUS_FIELD_MAX];
size_t partial_len;
} status_parser_t;
/* porcelain-v1 status columns (X/Y): documented codes plus the lowercase
* submodule variants and type-change 'T'. Anything else is not a record
* header, so a malformed stream fails closed instead of being misread. */
static bool status_code_ok(char c) {
switch (c) {
case ' ':
case 'M':
case 'A':
case 'D':
case 'R':
case 'C':
case 'U':
case '?':
case '!':
case 'T':
case 'm':
case 'a':
case 'd':
case 'r':
case 'c':
case 'u':
case 't':
return true;
default:
return false;
}
}
/* Retain one bounded sample; the running total always advances so the caller
* sees the true stream count even when samples are capped or OOM. */
static void status_add_sample(int *total, char ***samples, int *sample_count, bool *truncated,
int max_samples, const char *path, size_t path_len) {
(*total)++;
if (*sample_count >= max_samples) {
*truncated = true;
return;
}
char *copy = (char *)cbm_alloc(CBM_MEM_CLASS_OTHER, path_len + 1);
if (!copy) {
*truncated = true;
return;
}
memcpy(copy, path, path_len);
copy[path_len] = '\0';
char **grown = (char **)cbm_realloc(CBM_MEM_CLASS_OTHER, *samples,
(size_t)(*sample_count + 1) * sizeof(char *));
if (!grown) {
cbm_free(CBM_MEM_CLASS_OTHER, copy);
*truncated = true;
return;
}
*samples = grown;
(*samples)[*sample_count] = copy;
(*sample_count)++;
}
/* Parse one complete NUL-delimited field. Returns false on malformed input,
* which fails the whole snapshot closed. */
static bool status_parse_record(cbm_worktree_status_t *out, status_parser_t *parser,
const char *field, size_t field_len) {
if (parser->expecting_source) {
parser->expecting_source = false;
return true; /* second path of a rename/copy record — not counted */
}
if (field_len < STATUS_HEADER_LEN || field[2] != ' ' || !status_code_ok(field[0]) ||
!status_code_ok(field[1])) {
return false;
}
const char *path = field + STATUS_HEADER_LEN;
size_t path_len = field_len - STATUS_HEADER_LEN;
if (field[0] == '?' && field[1] == '?') {
status_add_sample(&out->untracked_count, &out->untracked_paths,
&out->untracked_sample_count, &out->untracked_truncated,
parser->max_samples, path, path_len);
return true;
}
if (field[0] == 'R' || field[0] == 'C' || field[1] == 'R' || field[1] == 'C') {
parser->expecting_source = true;
}
status_add_sample(&out->tracked_count, &out->tracked_paths, &out->tracked_sample_count,
&out->tracked_truncated, parser->max_samples, path, path_len);
return true;
}
/* Feed a chunk of the NUL-delimited stream through the bounded record parser. */
static void status_feed(status_parser_t *parser, const char *data, size_t data_len) {
size_t i = 0;
while (i < data_len) {
if (parser->partial_len >= STATUS_FIELD_MAX) {
parser->parse_ok = false; /* field exceeded the bound: malformed */
return;
}
size_t j = i;
while (j < data_len && data[j] != '\0' &&
parser->partial_len + (j - i) < STATUS_FIELD_MAX) {
j++;
}
size_t take = j - i;
memcpy(parser->partial + parser->partial_len, data + i, take);
parser->partial_len += take;
i += take;
if (i < data_len && data[i] == '\0') {
if (!status_parse_record(parser->out, parser, parser->partial, parser->partial_len)) {
parser->parse_ok = false;
return;
}
parser->partial_len = 0;
i++; /* consume the record terminator */
} else if (i >= data_len) {
return; /* chunk exhausted mid-record */
}
}
}
int cbm_git_worktree_status(const char *validated_root, int max_samples,
cbm_worktree_status_t *out) {
if (!out) {
return CBM_NOT_FOUND;
}
memset(out, 0, sizeof(*out));
if (!validated_root || !validated_root[0] || max_samples < 0) {
return CBM_NOT_FOUND;
}
if (!git_validate_repo_path(validated_root)) {
return CBM_NOT_FOUND;
}
char cmd[GIT_CMD_MAX];
#ifdef _WIN32
const char *null_dev = "NUL";
#else
const char *null_dev = "/dev/null";
#endif
int n = snprintf(cmd, sizeof(cmd),
"git -C \"%s\" status --porcelain=v1 -z --untracked-files=all 2>%s",
validated_root, null_dev);
if (n < 0 || n >= (int)sizeof(cmd)) {
return CBM_NOT_FOUND;
}
/* An inherited GIT_DIR/GIT_WORK_TREE (a git hook, an editor) overrides
* `git -C`, which would report another repository's worktree here. */
FILE *fp = cbm_popen_git(cmd);
if (!fp) {
return 0; /* out is zeroed: available=false */
}
status_parser_t parser;
memset(&parser, 0, sizeof(parser));
parser.out = out;
parser.max_samples = max_samples;
parser.parse_ok = true;
char chunk[STATUS_CHUNK_MAX];
size_t got;
bool io_error = false;
while (parser.parse_ok && (got = fread(chunk, 1, sizeof(chunk), fp)) > 0) {
status_feed(&parser, chunk, got);
}
if (ferror(fp)) {
io_error = true;
}
int rc = cbm_pclose(fp);
if (rc != 0 || !parser.parse_ok || io_error || parser.partial_len > 0) {
/* Fail closed: any deviation from a clean, complete status stream is a
* machine-readable "unavailable", never a clean worktree. */
cbm_git_worktree_status_free(out);
return 0;
}
out->available = true;
return 0;
}
void cbm_git_worktree_status_free(cbm_worktree_status_t *st) {
if (!st) {
return;
}
for (int i = 0; i < st->tracked_sample_count; i++) {
cbm_free(CBM_MEM_CLASS_OTHER, st->tracked_paths[i]);
}
cbm_free(CBM_MEM_CLASS_OTHER, st->tracked_paths);
for (int i = 0; i < st->untracked_sample_count; i++) {
cbm_free(CBM_MEM_CLASS_OTHER, st->untracked_paths[i]);
}
cbm_free(CBM_MEM_CLASS_OTHER, st->untracked_paths);
memset(st, 0, sizeof(*st));
}
src/git/git_context.h
+55
View File
@@ -20,6 +20,25 @@ typedef struct {
char *base_sha;
} cbm_git_context_t;
/* True when path is a LINKED git worktree (`git worktree add`) or a
* subdirectory of one.
*
* Plumbing-only, no subprocess. Walk ancestors until a git anchor. A linked
* worktree's <root>/.git is a regular file holding a "gitdir: <path>" pointer
* AND that gitdir contains a `commondir` file. The walk stops at any other
* anchor: a main checkout (`.git` is a directory) or a submodule (gitlink
* file whose gitdir, <super>/.git/modules/<name>, has no commondir).
*
* Callers run this on every session start, so it stays fork-free; the richer
* cbm_git_context_resolve() shells out to git and is not usable on that path. */
bool cbm_git_is_linked_worktree(const char *path);
/* True when both paths sit in the same linked worktree. Identity is the
* gitdir pointer of each path's linked-worktree anchor, so a worktree nested
* inside another does not count as that parent. False when either path is not
* inside a linked worktree. */
bool cbm_git_same_linked_worktree(const char *a, const char *b);
int cbm_git_context_resolve(const char *path, cbm_git_context_t *out);
/* Only the is_git and branch fields of cbm_git_context_resolve, from the same
* two git commands it uses for them (2 git processes instead of 7). branch
@@ -31,4 +50,40 @@ void cbm_git_context_free(cbm_git_context_t *ctx);
char *cbm_git_context_branch_qn(const char *project_name, const cbm_git_context_t *ctx);
int cbm_git_context_props_json(const cbm_git_context_t *ctx, char *buf, int buf_size);
/* Bounded snapshot of the git worktree status for one validated repo root.
*
* available is true ONLY when `git status --porcelain=v1 -z --untracked-files=all`
* exited 0 AND every NUL-delimited record parsed cleanly. Any other outcome —
* shell-unsafe path, spawn failure, nonzero exit, malformed/oversized record,
* trailing partial record — leaves available=false with zero counts and no
* samples. Callers MUST treat !available as "status unavailable", never as a
* clean worktree.
*
* The entire stream is counted, but only max_samples paths per class (tracked
* / untracked) are ever retained, in stream order; exceeding the cap sets the
* matching *_truncated flag. Rename/copy records are counted once (their two
* NUL-separated paths are consumed without counting the second), and the
* sampled path is the record's NEW path. Ignored files never appear because
* --ignored is not requested.
*
* cbm_git_worktree_status returns 0 when *out has been filled (available tells
* whether the snapshot succeeded) and CBM_NOT_FOUND for invalid arguments
* (NULL root/out or max_samples < 0). The caller owns the returned samples via
* cbm_git_worktree_status_free. */
typedef struct {
bool available;
int tracked_count;
int untracked_count;
char **tracked_paths; /* heap-owned samples, tracked_sample_count entries */
int tracked_sample_count;
bool tracked_truncated;
char **untracked_paths;
int untracked_sample_count;
bool untracked_truncated;
} cbm_worktree_status_t;
int cbm_git_worktree_status(const char *validated_root, int max_samples,
cbm_worktree_status_t *out);
void cbm_git_worktree_status_free(cbm_worktree_status_t *st);
#endif
src/main.c
+6
View File
@@ -902,6 +902,12 @@ static int run_cli(int argc, char **argv, cbm_project_lock_manager_t *project_lo
* own here, and only here (cbm_sqlite_dedicated_heap). */
cbm_sqlite_dedicated_heap(true);
cbm_memev_process_role("worker");
/* A full index saturates every core; run it below normal priority so
* interactive CLI/MCP queries are not starved. Before any indexing
* thread exists, so they all inherit it. Failure is harmless. */
if (!cbm_lower_cpu_priority()) {
cbm_log_info("index.worker.priority", "lowered", "false");
}
}
cbm_index_set_worker_role_options(index_worker, response_out, worker_single_thread,
worker_marker, worker_quarantine,
src/mcp/mcp.c
+224 -3
View File
@@ -49,6 +49,8 @@ enum {
* promise. The actual cross-platform contract is this deterministic UTF-8
* byte ceiling, applied only at whole semantic-unit boundaries. */
MCP_OUTPUT_BYTES_PER_TOKEN_ESTIMATE = 4,
MCP_STATUS_SAMPLE_MAX = 16, /* per-class path samples in verbose freshness */
MCP_REASONS_MAX = 8, /* freshness reasons array ceiling (see below) */
};
#define MCP_MS_TO_US 1000LL
#define MCP_S_TO_US 1000000LL
@@ -551,6 +553,9 @@ static const tool_def_t TOOLS[] = {
"\"Name override; Non-ASCII bytes are encoded; unsafe characters normalized.\"},"
"\"persistence\":{\"type\":\"boolean\",\"default\":false,\"description\":"
"\"Write .codebase-memory/graph.db.zst.\"},"
"\"index_worktree\":{\"type\":\"boolean\",\"default\":false,\"description\":"
"\"Index repo_path even when it is a linked git worktree and the "
"ignore_worktrees config key is enabled. No effect otherwise.\"},"
"\"doc_candidates\":{\"type\":\"boolean\",\"description\":"
"\"Doc-code candidates; default: the doc_candidates setting, else on for full, off for "
"moderate/fast.\"},"
@@ -7789,13 +7794,169 @@ static void add_watch_status_json(cbm_mcp_server_t *srv, yyjson_mut_doc *doc, yy
yyjson_mut_obj_add_val(doc, root, "watch", watch);
}
/* Emit the bounded worktree-status snapshot inside the freshness block.
* Fail-closed: status_available is false whenever git status could not run
* clean, in which case the API guarantees zero counts and no samples — a
* non-git root or missing git is NEVER presented as a clean worktree. Ignored
* paths are deliberately absent (no --ignored in the underlying query) and
* must not be confused with tracked/untracked sources. */
static void add_worktree_status_json(yyjson_mut_doc *doc, yyjson_mut_val *freshness,
const cbm_worktree_status_t *st) {
yyjson_mut_obj_add_bool(doc, freshness, "status_available", st->available);
yyjson_mut_val *tracked = yyjson_mut_obj(doc);
yyjson_mut_obj_add_int(doc, tracked, "count", st->tracked_count);
yyjson_mut_val *tpaths = yyjson_mut_arr(doc);
for (int i = 0; i < st->tracked_sample_count; i++) {
yyjson_mut_arr_add_strcpy(doc, tpaths, st->tracked_paths[i]);
}
yyjson_mut_obj_add_val(doc, tracked, "paths", tpaths);
yyjson_mut_obj_add_bool(doc, tracked, "truncated", st->tracked_truncated);
yyjson_mut_obj_add_val(doc, freshness, "tracked_changes", tracked);
yyjson_mut_val *untracked = yyjson_mut_obj(doc);
yyjson_mut_obj_add_int(doc, untracked, "count", st->untracked_count);
yyjson_mut_val *upaths = yyjson_mut_arr(doc);
for (int i = 0; i < st->untracked_sample_count; i++) {
yyjson_mut_arr_add_strcpy(doc, upaths, st->untracked_paths[i]);
}
yyjson_mut_obj_add_val(doc, untracked, "paths", upaths);
yyjson_mut_obj_add_bool(doc, untracked, "truncated", st->untracked_truncated);
yyjson_mut_obj_add_val(doc, freshness, "untracked_source", untracked);
}
/* BT-240: fail-closed freshness verdict against the indexed-checkout identity
* recorded with the DB at the successful staged-generation boundary. A live
* checkout SHA is not proof of the generation that produced graph content, so
* the verdict comes from that recorded identity, the live git HEAD and the
* bounded worktree status (tracked/untracked deltas):
* - no indexed SHA → unknown / unavailable
* - indexed SHA differs from the live git HEAD → stale / mismatch
* - tracked changes present → stale / tracked
* - untracked sources present → prevents current
* - equal SHA + status available + no changes → current
* Report-only: it never triggers indexing. Verbose-only and read-only; the
* live checkout is resolved fresh from the project root (never mutated). */
static void add_index_freshness_json(yyjson_mut_doc *doc, yyjson_mut_val *root, cbm_store_t *store,
const char *project, const char *root_path,
const char *indexed_generation) {
yyjson_mut_val *freshness = yyjson_mut_obj(doc);
if (indexed_generation && indexed_generation[0]) {
yyjson_mut_obj_add_strcpy(doc, freshness, "indexed_generation", indexed_generation);
} else {
yyjson_mut_obj_add_str(doc, freshness, "indexed_generation", "");
}
cbm_coverage_meta_t meta = {0};
bool have_meta = store && cbm_store_coverage_meta_get(store, project, &meta) == CBM_STORE_OK;
const char *indexed_sha = NULL;
if (have_meta && meta.indexed_checkout_sha && meta.indexed_checkout_sha[0]) {
indexed_sha = meta.indexed_checkout_sha;
}
cbm_git_context_t ctx = {0};
(void)cbm_git_context_resolve(root_path, &ctx);
const char *checkout_sha = ctx.head_sha && ctx.head_sha[0] ? ctx.head_sha : NULL;
cbm_worktree_status_t st = {0};
int status_rc = cbm_git_worktree_status(root_path, MCP_STATUS_SAMPLE_MAX, &st);
bool status_available = status_rc == 0 && st.available;
add_worktree_status_json(doc, freshness, &st);
if (indexed_sha) {
yyjson_mut_obj_add_strcpy(doc, freshness, "indexed_checkout_sha", indexed_sha);
} else {
yyjson_mut_obj_add_null(doc, freshness, "indexed_checkout_sha");
}
if (checkout_sha) {
yyjson_mut_obj_add_strcpy(doc, freshness, "checkout_sha", checkout_sha);
} else {
yyjson_mut_obj_add_null(doc, freshness, "checkout_sha");
}
/* Verdict/reasons composition. Stale reasons (identity mismatch, tracked
* changes) win over everything; a missing indexed identity is unknown
* regardless of live state; status unavailability and untracked sources
* both prevent "current" but only yield stale when a stale reason is
* already present. The reasons array keeps every applicable code in a
* stable order; the singular reason stays as the first (dominant) one for
* compatibility with consumers that read it directly. */
bool sha_present = indexed_sha != NULL;
bool live_present = checkout_sha != NULL;
bool sha_mismatch = sha_present && live_present && strcmp(indexed_sha, checkout_sha) != 0;
bool has_tracked = st.tracked_count > 0;
bool has_untracked = st.untracked_count > 0;
bool has_stale = sha_mismatch || has_tracked;
const char *verdict;
if (!sha_present) {
verdict = "unknown";
} else if (has_stale) {
verdict = "stale";
} else if (!live_present) {
verdict = "unknown";
} else if (!status_available) {
verdict = "unknown";
} else if (has_untracked) {
verdict = "unknown";
} else {
verdict = "current";
}
const char *reasons[MCP_REASONS_MAX];
int n_reasons = 0;
if (!sha_present) {
reasons[n_reasons++] = "indexed_checkout_unavailable";
}
if (sha_mismatch) {
reasons[n_reasons++] = "indexed_checkout_mismatch";
}
if (has_tracked) {
reasons[n_reasons++] = "tracked_changes_present";
}
if (!status_available) {
reasons[n_reasons++] = "status_unavailable";
}
if (has_untracked) {
reasons[n_reasons++] = "untracked_not_indexed";
}
if (n_reasons == 0) {
reasons[n_reasons++] = "indexed_checkout_current";
}
const char *reason = reasons[0];
const char *recommended_action;
if (strcmp(verdict, "current") == 0) {
recommended_action = "use_graph";
} else if (strcmp(verdict, "stale") == 0) {
recommended_action = "reindex_to_match_checkout";
} else {
recommended_action = "reindex_to_record_indexed_checkout";
}
yyjson_mut_obj_add_str(doc, freshness, "verdict", verdict);
yyjson_mut_obj_add_str(doc, freshness, "reason", reason);
yyjson_mut_val *reasons_val = yyjson_mut_arr(doc);
for (int i = 0; i < n_reasons; i++) {
yyjson_mut_arr_add_str(doc, reasons_val, reasons[i]);
}
yyjson_mut_obj_add_val(doc, freshness, "reasons", reasons_val);
yyjson_mut_obj_add_str(doc, freshness, "recommended_action", recommended_action);
yyjson_mut_obj_add_val(doc, root, "freshness", freshness);
if (have_meta) {
cbm_store_coverage_meta_clear(&meta);
}
cbm_git_worktree_status_free(&st);
cbm_git_context_free(&ctx);
}
static char *handle_index_status(cbm_mcp_server_t *srv, const char *args) {
char *project = get_project_arg(args);
cbm_store_t *store = resolve_store(srv, project);
REQUIRE_STORE(store, project);
/* The git context block (worktree/shadow path variants) only matters when
* debugging index-location issues — gate it so the common status call
* stays lean. */
/* The git context block (worktree/shadow path variants) and the freshness
* verdict only matter when debugging index-location issues — gate them so
* the common status call stays lean. */
bool verbose = cbm_mcp_get_bool_arg(args, "verbose");
char *diagnostics = cbm_mcp_get_string_arg(args, "diagnostics");
int coverage_samples = 0;
@@ -7840,6 +8001,8 @@ static char *handle_index_status(cbm_mcp_server_t *srv, const char *args) {
proj_info.indexed_at ? proj_info.indexed_at : "");
if (verbose) {
add_git_context_json(doc, root, proj_info.root_path);
add_index_freshness_json(doc, root, store, project, proj_info.root_path,
proj_info.indexed_at);
}
}
add_coverage_report(doc, root, store, project, have_proj_info ? proj_info.indexed_at : NULL,
@@ -13050,6 +13213,20 @@ static char *handle_index_repository(cbm_mcp_server_t *srv, const char *args) {
return cbm_mcp_text_result(boundary_err, true);
}
/* ignore_worktrees: an EXPLICIT index_repository call on a linked worktree
* is refused with the two ways forward (per-call override, or turn the
* setting off) rather than silently skipped — a silent success would be
* indistinguishable from a real index to the caller. */
if (cbm_mcp_ignore_worktrees_enabled(srv) && !cbm_mcp_get_bool_arg(args, "index_worktree") &&
cbm_git_is_linked_worktree(repo_path)) {
index_args_free(repo_path, mode_str, name_override);
return cbm_mcp_text_result(
"repo_path is a linked git worktree and ignore_worktrees is enabled. Pass "
"index_worktree=true to index it anyway, or run: codebase-memory-mcp config set "
"ignore_worktrees false",
true);
}
if (mode_str && strcmp(mode_str, "cross-repo-intelligence") == 0) {
if (async_mode) {
index_args_free(repo_path, mode_str, name_override);
@@ -21551,6 +21728,44 @@ static bool auto_watch_enabled(cbm_mcp_server_t *srv) {
return cbm_config_get_bool(srv->config, CBM_CONFIG_AUTO_WATCH, true);
}
/* ignore_worktrees config: gates automatic indexing of LINKED git worktrees
* (default off, so existing setups keep indexing them). Users who create many
* short-lived worktrees can stop each throwaway checkout from registering a
* new permanent project with `config set ignore_worktrees true`. */
bool cbm_mcp_ignore_worktrees_enabled(const cbm_mcp_server_t *srv) {
if (!srv || !srv->config) {
return false; /* default off */
}
return cbm_config_get_bool(srv->config, CBM_CONFIG_IGNORE_WORKTREES, false);
}
/* The same key for a caller whose server may have no store: the stand-alone
* lifecycle hook builds one with cbm_mcp_server_new(NULL), and the daemon lends
* its session server, which this must not modify. A server with a store answers
* from it. Otherwise the runtime store is opened only to read this key, and only
* when it exists: a missing store leaves every key at its default, so this read
* never creates one. */
bool cbm_mcp_ignore_worktrees_runtime_enabled(const cbm_mcp_server_t *srv) {
if (srv && srv->config) {
return cbm_mcp_ignore_worktrees_enabled(srv);
}
const char *store_dir = cbm_resolve_cache_dir();
if (!store_dir) {
return false;
}
char store_path[CBM_SZ_4K];
int written = snprintf(store_path, sizeof(store_path), "%s/" CBM_CONFIG_DB_FILENAME, store_dir);
cbm_path_info_t info;
if (written < 0 || (size_t)written >= sizeof(store_path) ||
cbm_path_info_utf8(store_path, &info) != CBM_PATH_INFO_OK || !info.is_regular) {
return false;
}
cbm_config_t *config = cbm_config_open(store_dir);
bool enabled = config && cbm_config_get_bool(config, CBM_CONFIG_IGNORE_WORKTREES, false);
cbm_config_close(config);
return enabled;
}
/* Register the session project with the background watcher for ongoing
* change detection — unless auto_watch is disabled. */
static void register_watcher_if_enabled(cbm_mcp_server_t *srv) {
@@ -21705,6 +21920,12 @@ static void maybe_auto_index(cbm_mcp_server_t *srv) {
return;
}
if (cbm_mcp_ignore_worktrees_enabled(srv) && cbm_git_is_linked_worktree(srv->session_root)) {
cbm_log_info("autoindex.skip", "reason", "linked_worktree", "project",
srv->session_project);
return;
}
/* Quick tracked-file count check to avoid OOM on massive repos. */
int file_count = -1;
#ifdef CBM_ENABLE_TEST_SEAMS
src/mcp/mcp_internal.h
+10
View File
@@ -86,6 +86,16 @@ const char *cbm_mcp_edge_strategy_class(const char *strategy);
bool cbm_mcp_auto_index_within_file_limit(const char *root_path, int file_limit,
int *file_count_out);
/* True when the `ignore_worktrees` config key is on for this server (default
* off). Callers pair it with cbm_git_is_linked_worktree() to decide whether an
* automatic index of a linked worktree should be skipped. */
bool cbm_mcp_ignore_worktrees_enabled(const cbm_mcp_server_t *srv);
/* The same key when srv may have no store (the lifecycle hook). Never attaches
* a store to srv and never creates the runtime store; reads it only when it
* already exists. */
bool cbm_mcp_ignore_worktrees_runtime_enabled(const cbm_mcp_server_t *srv);
/* detect_changes seed scoping (#1363): does `node`'s line range overlap any
* recorded hunk for `file`? Exposed for direct unit testing of the overlap
* logic, independent of the git/subprocess/index plumbing around it. */
src/pipeline/lsp_resolve.h
+1
View File
@@ -388,6 +388,7 @@ static inline bool cbm_pipeline_invocation_reason_join_strategy(const char *stra
strcmp(strategy, "lsp_method_ref_ctor_synth") == 0 ||
strcmp(strategy, "lsp_dict_dispatch") == 0 ||
strcmp(strategy, "lsp_import_alias") == 0 ||
strcmp(strategy, "lsp_constructor_init") == 0 ||
strcmp(strategy, "php_method_dynamic") == 0);
}
src/pipeline/pipeline.c
+5
View File
@@ -1631,6 +1631,10 @@ cbm_index_resource_violation_t *cbm_pipeline_resource_violation(cbm_pipeline_t *
return p ? &p->resource_violation : NULL;
}
const char *cbm_pipeline_indexed_checkout_sha(const cbm_pipeline_t *p) {
return p ? p->git_ctx.head_sha : NULL;
}
atomic_int *cbm_pipeline_cancelled_ptr(cbm_pipeline_t *p) {
return p ? p->cancelled : NULL;
}
@@ -4165,6 +4169,7 @@ static int dump_and_persist_hashes(cbm_pipeline_t *p, const cbm_file_hash_t *bas
.hash_records_complete = true,
.unresolved_calls_complete =
pipeline_unresolved_capture_complete(p, coverage_rows_available),
.indexed_checkout_sha = p->git_ctx.head_sha,
},
.surface_rows = p->surface_rows,
.surface_row_count = p->surface_row_count,
src/pipeline/pipeline_incremental.c
+2
View File
@@ -3858,6 +3858,7 @@ static int run_closure_delta(cbm_pipeline_t *p, const char *db_path, const char
.hash_records_complete = true,
.unresolved_calls_complete = incremental_capture_complete(
coverage_rows_available, unresolved_complete, retained_unresolved_complete),
.indexed_checkout_sha = cbm_pipeline_indexed_checkout_sha(p),
},
.surface_rows = NULL,
.surface_row_count = 0,
@@ -4543,6 +4544,7 @@ int cbm_pipeline_run_incremental(cbm_pipeline_t *p, const char *db_path, cbm_fil
.hash_records_complete = true,
.unresolved_calls_complete = incremental_capture_complete(
coverage_rows_available, unresolved_complete, retained_unresolved_complete),
.indexed_checkout_sha = cbm_pipeline_indexed_checkout_sha(p),
};
/* Publish surfaces: the surviving previous rows plus this run's fresh
* ones (closure route). The legacy test route publishes none — its
src/pipeline/pipeline_internal.h
+8 -1
View File
@@ -1684,8 +1684,13 @@ int cbm_pipeline_build_fresh_semantic_manifest(cbm_pipeline_t *p, const char *pr
* are preserved and dotted-name collisions are disambiguated before section
* references resolve. Old indices rebuild once so Section nodes, MENTIONS
* and diagram owners agree.
* 13: a Next.js App Router route handler, the HTTP verb Function a route.ts
* / route.js under app/ or src/app/ exports, carries the route_path its
* directories name and HANDLES its Route (extract_nextjs.c). An index
* built before has none of these Routes for its unchanged route files,
* so it rebuilds once on upgrade.
* The unresolved-call coverage threshold remains independent. */
enum { CBM_SEMANTIC_INDEX_VERSION = 12 };
enum { CBM_SEMANTIC_INDEX_VERSION = 13 };
typedef struct {
cbm_gbuf_t *gbuf;
@@ -1878,6 +1883,8 @@ const cbm_test_declarations_t *cbm_pipeline_test_declarations(const cbm_pipeline
bool cbm_pipeline_project_source_matches(const cbm_pipeline_t *p, const cbm_userconfig_t *fresh);
const cbm_index_resource_policy_t *cbm_pipeline_resource_policy(const cbm_pipeline_t *p);
cbm_index_resource_violation_t *cbm_pipeline_resource_violation(cbm_pipeline_t *p);
/* Borrowed checkout identity captured and validated for this pipeline run. */
const char *cbm_pipeline_indexed_checkout_sha(const cbm_pipeline_t *p);
atomic_int *cbm_pipeline_cancelled_ptr(cbm_pipeline_t *p);
/* Record committed graph size (#334 gate axis) from the incremental path,
* which cannot see the opaque cbm_pipeline struct. Call before the dump. */
src/store/store.c
+96 -3
View File
@@ -340,6 +340,26 @@ bool cbm_store_edges_schema_current(cbm_store_t *s) {
return true;
}
/* Best-effort probe for the BT-240 index_checkout table. Writable opens run
* init_schema (which creates it), so false is expected only on read-only
* legacy DBs opened via the query path — those must keep working and simply
* report no indexed-checkout identity. */
static bool index_checkout_table_exists(cbm_store_t *s) {
if (!s || !s->db) {
return false;
}
sqlite3_stmt *stmt = NULL;
if (sqlite3_prepare_v2(s->db,
"SELECT 1 FROM sqlite_master WHERE type = 'table' "
"AND name = 'index_checkout';",
CBM_NOT_FOUND, &stmt, NULL) != SQLITE_OK) {
return false;
}
bool has = sqlite3_step(stmt) == SQLITE_ROW;
sqlite3_finalize(stmt);
return has;
}
static int init_schema(cbm_store_t *s) {
const char *ddl =
"CREATE TABLE IF NOT EXISTS projects ("
@@ -495,6 +515,14 @@ static int init_schema(cbm_store_t *s) {
" coverage_version INTEGER NOT NULL DEFAULT 1,"
" hash_records_complete INTEGER NOT NULL DEFAULT 0,"
" unresolved_calls_complete INTEGER NOT NULL DEFAULT 0"
");"
/* BT-240: the checkout an index was built from. A table of its own,
* not an index_coverage_meta column: it is source identity, which the
* pinned graph-digest tables deliberately do not bind, and a new
* table needs no migration of existing databases. */
"CREATE TABLE IF NOT EXISTS index_checkout ("
" project TEXT PRIMARY KEY REFERENCES projects(name) ON DELETE CASCADE,"
" indexed_checkout_sha TEXT NOT NULL"
");";
int rc = exec_sql(s, ddl);
@@ -3090,6 +3118,7 @@ int cbm_store_delete_project(cbm_store_t *s, const char *name) {
static const char *cleanup_sql[] = {
"DELETE FROM index_coverage WHERE project = ?1;",
"DELETE FROM index_coverage_meta WHERE project = ?1;",
"DELETE FROM index_checkout WHERE project = ?1;",
"DELETE FROM projects WHERE name = ?1 || '::missed';",
};
/* doc_link_unresolved exists only in databases published by a build that
@@ -4838,6 +4867,34 @@ static int cov_rebuild_shadow_graph(cbm_store_t *s, const char *project) {
return CBM_STORE_OK;
}
/* Record (or, with no sha, clear) the checkout a project's index was built
* from. Runs inside the caller's coverage transaction, so a failed replace
* keeps the previous identity. */
static int index_checkout_write(cbm_store_t *s, const char *project, const char *sha) {
bool record = sha && sha[0];
sqlite3_stmt *stmt = NULL;
if (sqlite3_prepare_v2(s->db,
record ? "INSERT INTO index_checkout (project, indexed_checkout_sha) "
"VALUES (?1, ?2) ON CONFLICT(project) DO UPDATE SET "
"indexed_checkout_sha=?2;"
: "DELETE FROM index_checkout WHERE project = ?1;",
CBM_NOT_FOUND, &stmt, NULL) != SQLITE_OK) {
store_set_error_sqlite(s, "index checkout write prepare");
return CBM_STORE_ERR;
}
bind_text(stmt, SKIP_ONE, project);
if (record) {
bind_text(stmt, ST_COL_2, sha);
}
int rc = sqlite3_step(stmt);
sqlite3_finalize(stmt);
if (rc != SQLITE_DONE) {
store_set_error_sqlite(s, "index checkout write");
return CBM_STORE_ERR;
}
return CBM_STORE_OK;
}
/* Materialize once at publication, after replacement and deleted-file pruning.
* json_each sees a safe marker array for malformed/legacy non-array payloads.
* The side table cascades with its authoritative coverage rows. */
@@ -4893,7 +4950,7 @@ static int coverage_write_metadata(cbm_store_t *s, const char *project,
store_set_error_sqlite(s, "coverage meta delete");
return CBM_STORE_ERR;
}
return CBM_STORE_OK;
return index_checkout_write(s, project, NULL);
}
char recorded_at[CBM_SZ_64];
if (meta->recorded_at && meta->recorded_at[0]) {
@@ -4943,7 +5000,7 @@ static int coverage_write_metadata(cbm_store_t *s, const char *project,
store_set_error_sqlite(s, "coverage meta upsert");
return CBM_STORE_ERR;
}
return CBM_STORE_OK;
return index_checkout_write(s, project, meta->indexed_checkout_sha);
}
int cbm_store_coverage_replace_ex(cbm_store_t *s, const char *project,
@@ -5218,9 +5275,45 @@ void cbm_store_coverage_meta_clear(cbm_coverage_meta_t *meta) {
free((char *)meta->index_mode);
free((char *)meta->recorded_at);
free((char *)meta->recording_status);
cbm_free(CBM_MEM_CLASS_STORE, (char *)meta->indexed_checkout_sha);
memset(meta, 0, sizeof(*meta));
}
/* Fill out->indexed_checkout_sha from index_checkout. A legacy read-only DB
* (query opens skip init_schema) may lack the table: no identity, not an
* error. On failure out is cleared. */
static int index_checkout_read(cbm_store_t *s, const char *project, cbm_coverage_meta_t *out) {
if (!index_checkout_table_exists(s)) {
return CBM_STORE_OK;
}
sqlite3_stmt *stmt = NULL;
if (sqlite3_prepare_v2(s->db,
"SELECT indexed_checkout_sha FROM index_checkout WHERE project = ?1;",
CBM_NOT_FOUND, &stmt, NULL) != SQLITE_OK) {
store_set_error_sqlite(s, "index checkout read prepare");
cbm_store_coverage_meta_clear(out);
return CBM_STORE_ERR;
}
bind_text(stmt, SKIP_ONE, project);
int rc = sqlite3_step(stmt);
if (rc == SQLITE_ROW) {
const char *sha = (const char *)sqlite3_column_text(stmt, 0);
if (sha && sha[0]) {
out->indexed_checkout_sha = cbm_mem_strdup(CBM_MEM_CLASS_STORE, sha);
rc = out->indexed_checkout_sha ? SQLITE_DONE : SQLITE_NOMEM;
} else {
rc = SQLITE_DONE;
}
}
sqlite3_finalize(stmt);
if (rc != SQLITE_DONE) {
store_set_error_sqlite(s, "index checkout read");
cbm_store_coverage_meta_clear(out);
return CBM_STORE_ERR;
}
return CBM_STORE_OK;
}
int cbm_store_coverage_meta_get(cbm_store_t *s, const char *project, cbm_coverage_meta_t *out) {
if (!out) {
return CBM_STORE_ERR;
@@ -5267,7 +5360,7 @@ int cbm_store_coverage_meta_get(cbm_store_t *s, const char *project, cbm_coverag
cbm_store_coverage_meta_clear(out);
return CBM_STORE_ERR;
}
return CBM_STORE_OK;
return index_checkout_read(s, project, out);
}
sqlite3_finalize(stmt);
if (rc != SQLITE_DONE) {
src/store/store.h
+5
View File
@@ -805,6 +805,11 @@ typedef struct {
int coverage_version;
bool hash_records_complete;
bool unresolved_calls_complete;
/* Git checkout identity frozen at the successful staged-generation
* boundary (BT-240), stored in the index_checkout table. NULL/"" when the
* run had no git context (non-git repo) or the DB predates that table.
* Owned by the row: meta_get allocates it, meta_clear frees it. */
const char *indexed_checkout_sha;
} cbm_coverage_meta_t;
/* Replace the project's coverage rows in one transaction, then prune rows for
tests/repro/repro_lsp_go_py.c
+26 -6
View File
@@ -64,8 +64,12 @@
* PYTHON STRATEGY INVENTORY — every literal "lsp_..." emitted by py_lsp.c
* (grep '"lsp_' internal/cbm/lsp/py_lsp.c), with its keying site:
* lsp_direct (py_lsp.c:1631) module-local f()
* lsp_constructor (py_lsp.c:1624) ClassName() where the name is a
* NAMED type in scope
* lsp_constructor ClassName() where the class declares no __init__
* of its own (an inherited one is not followed)
* → the Class
* lsp_constructor_init ClassName() where the class declares its own
* __init__ → that __init__. The textual callee
* leaf stays the class name; reason joins it.
* lsp_method (py_lsp.c:1731) obj.method() on a NAMED-typed
* receiver (covers self.other())
* lsp_super (py_lsp.c:1693) super().method() resolved on a
@@ -340,13 +344,24 @@ static const char kPyDirect[] =
"def caller(v):\n"
" return helper(v)\n";
/* lsp_constructor — ClassName() where the name is a NAMED type in scope
* (py_lsp.c:1620-1624: cbm_scope_lookup yields a NAMED type → emit constructor
* edge to the class QN). */
/* lsp_constructor — ClassName() where the class has no user __init__.
* The edge stays on the Class node. A class that defines __init__ is
* lsp_constructor_init below; strstr would otherwise treat that strategy
* as a hit for "lsp_constructor". */
static const char kPyConstructor[] =
"class Widget:\n"
" def label(self):\n"
" return 1\n"
"def caller():\n"
" return Widget()\n";
/* lsp_constructor_init — ClassName() resolves to the user __init__
* (issue #1642). reason carries the class-name leaf so the pipeline join
* still matches the textual call. */
static const char kPyConstructorInit[] =
"class Widget:\n"
" def __init__(self):\n"
" pass\n"
" self.ready = True\n"
"def caller():\n"
" return Widget()\n";
@@ -538,6 +553,10 @@ TEST(repro_lsp_py_constructor) {
return assert_lsp_strategy("main.py", kPyConstructor, "lsp_constructor");
}
TEST(repro_lsp_py_constructor_init) {
return assert_lsp_strategy("main.py", kPyConstructorInit, "lsp_constructor_init");
}
TEST(repro_lsp_py_method) {
return assert_lsp_strategy("main.py", kPyMethod, "lsp_method");
}
@@ -623,6 +642,7 @@ SUITE(repro_lsp_go_py) {
RUN_TEST(repro_lsp_py_direct);
RUN_TEST(repro_lsp_py_constructor);
RUN_TEST(repro_lsp_py_constructor_init);
RUN_TEST(repro_lsp_py_method);
RUN_TEST(repro_lsp_py_super);
RUN_TEST(repro_lsp_py_super_init);
tests/test_benchmark_runtime_isolation_contract.sh
Executable
+296
View File
@@ -0,0 +1,296 @@
#!/usr/bin/env bash
set -euo pipefail
# Runtime-isolation contract for the benchmark harnesses (#1696, follow-up to
# #1691).
#
# scripts/benchmark-index.sh and scripts/benchmark-search-graph.sh ran the
# product with no runtime or cache of their own: the index landed in the
# operator's live store, every one-shot joined the operator's account daemon,
# and the timings depended on whatever that daemon was doing. Drive both with
# an environment-probe fixture and require that no product process ever
# receives the caller's runtime or cache, that the index benchmark records
# the setup cost it now pays explicitly, and that a refused index fails the
# run, names its cause, and leaves nothing behind. A daemon that refuses to
# start or to stop fails the run the same way, and a kept runtime is handed
# over only once its daemon stopped.
ROOT="$(cd "$(dirname "$0")/.." && pwd)"
WORKDIR="$(mktemp -d)"
trap 'rm -rf "$WORKDIR"' EXIT
fail() {
echo "FAIL: $*" >&2
exit 1
}
normalize_path() {
local path=${1%$'\r'}
if command -v cygpath >/dev/null 2>&1; then
cygpath -u "$path" 2>/dev/null && return 0
fi
printf '%s\n' "${path//\\//}"
}
ENV_PROBE="$WORKDIR/environment-probe"
cat > "$ENV_PROBE" <<'EOF'
#!/usr/bin/env bash
printf '%s\t%s\n' "${CBM_CACHE_DIR-}" "${CBM_RUNTIME_DIR-}" >> "$CBM_BENCH_ENV_PROBE"
if [[ "${1-} ${2-}" == "cli index_repository" ]]; then
[[ -z "${CBM_BENCH_REQUEST_LOG-}" ]] || printf '%s\n' "${3-}" >> "$CBM_BENCH_REQUEST_LOG"
if [[ -n "${CBM_BENCH_PROBE_INDEX_OK-}" ]]; then
printf '%s\n' '{"project":"probe"}'
exit 0
fi
echo "probe: index refused" >&2
exit 1
fi
if [[ "${1-} ${2-}" == "daemon start" && -n "${CBM_BENCH_PROBE_START_REFUSED-}" ]]; then
echo "probe: daemon start refused" >&2
exit 1
fi
# The product reports a busy refusal (a committed client still uses the
# daemon) on stdout, so that is where the fixture reports its own.
if [[ "${1-} ${2-}" == "daemon stop" && -n "${CBM_BENCH_PROBE_STOP_REFUSED-}" ]]; then
echo "probe: daemon NOT stopped, a committed client still uses it"
exit 1
fi
[[ "${1-} ${2-}" == "daemon status" ]] && exit 1
exit 0
EOF
chmod +x "$ENV_PROBE"
CALLER_CACHE="$WORKDIR/caller-cache"
CALLER_RUNTIME="$WORKDIR/caller-runtime"
REPO="$WORKDIR/repo"
mkdir -p "$CALLER_CACHE" "$CALLER_RUNTIME" "$REPO"
echo 'def bench(): return 1' > "$REPO/bench.py"
CALLER_CACHE_NORMALIZED=$(normalize_path "$CALLER_CACHE")
CALLER_RUNTIME_NORMALIZED=$(normalize_path "$CALLER_RUNTIME")
# The fixture answers nothing, so the search benchmark stops once the index
# reports no project; only the environment handed to the product is under test.
assert_isolated() {
local harness="$1" env_log="$2" private_root=""
[[ -s "$env_log" ]] || fail "$harness did not execute the environment-probe fixture"
while IFS=$'\t' read -r child_cache_raw child_runtime_raw; do
local child_cache child_runtime
child_cache=$(normalize_path "$child_cache_raw")
child_runtime=$(normalize_path "$child_runtime_raw")
if [[ -z "$child_runtime" || "$child_runtime" == "$CALLER_RUNTIME_NORMALIZED" ]]; then
fail "$harness exposed the caller CBM_RUNTIME_DIR to a product process"
fi
if [[ -z "$child_cache" || "$child_cache" == "$CALLER_CACHE_NORMALIZED" ]]; then
fail "$harness exposed the caller CBM_CACHE_DIR to a product process"
fi
if [[ "${child_runtime%/*}" != "${child_cache%/*}" ||
"${child_runtime##*/}" != "runtime" || "${child_cache##*/}" != "cache" ]]; then
fail "$harness runtime/cache were not isolated beneath one private root"
fi
if [[ -n "$private_root" && "$private_root" != "${child_runtime%/*}" ]]; then
fail "$harness switched private roots mid-run"
fi
private_root="${child_runtime%/*}"
done < "$env_log"
[[ ! -e "$private_root" ]] || fail "$harness left its private root behind: $private_root"
}
# The fixture refuses the index. That must fail the run — after the timing
# files are written, so the caller keeps its figures — and name its cause: the
# fixture's one stderr line has to reach the output.
INDEX_LOG="$WORKDIR/index-environment.log"
index_rc=0
CBM_CACHE_DIR="$CALLER_CACHE" \
CBM_RUNTIME_DIR="$CALLER_RUNTIME" \
CBM_BENCH_ENV_PROBE="$INDEX_LOG" \
"$ROOT/scripts/benchmark-index.sh" "$ENV_PROBE" probe "$REPO" "$WORKDIR/results" \
> "$WORKDIR/index.out" 2>&1 || index_rc=$?
[[ "$index_rc" -ne 0 ]] || fail "benchmark-index exited 0 after a refused index"
assert_isolated "benchmark-index" "$INDEX_LOG"
for metric in setup-time total-time index-time; do
[[ -s "$WORKDIR/results/probe/$metric.txt" ]] ||
fail "benchmark-index did not record $metric.txt"
done
grep -q -- '--- index stderr ---' "$WORKDIR/index.out" ||
fail "benchmark-index hid the index stderr behind its own message"
grep -q 'probe: index refused' "$WORKDIR/index.out" ||
fail "benchmark-index did not surface the cause of the index failure"
# The evaluation plan indexes a language and then reads that index from its own
# MCP session (docs/EVALUATION_PLAN.md §7). Asked to keep the runtime, a
# successful run must leave its root behind and record, sourceably, the paths
# that reach it — and they must be the paths the product processes actually
# used. Unasked, the root is gone (asserted above). The fixture answers this
# index with a minimal envelope, so what is kept is an index that succeeded.
KEEP_LOG="$WORKDIR/keep-environment.log"
keep_rc=0
CBM_CACHE_DIR="$CALLER_CACHE" \
CBM_RUNTIME_DIR="$CALLER_RUNTIME" \
CBM_BENCH_ENV_PROBE="$KEEP_LOG" \
CBM_BENCH_PROBE_INDEX_OK=1 \
CBM_BENCH_KEEP_RUNTIME=1 \
"$ROOT/scripts/benchmark-index.sh" "$ENV_PROBE" keep "$REPO" "$WORKDIR/results" \
> "$WORKDIR/keep.out" 2>&1 || keep_rc=$?
[[ "$keep_rc" -eq 0 ]] || fail "benchmark-index failed a run whose index succeeded (exit $keep_rc)"
KEPT_PROJECT=$(cat "$WORKDIR/results/keep/project.txt" 2>/dev/null || true)
[[ "${KEPT_PROJECT%$'\r'}" == "probe" ]] ||
fail "benchmark-index did not record the project the index reported: '${KEPT_PROJECT:-<none>}'"
HANDOFF="$WORKDIR/results/keep/runtime-root.txt"
[[ -s "$HANDOFF" ]] || fail "benchmark-index was asked to keep its runtime but recorded no handoff"
KEPT_ROOT=$(bash -c '. "$1" && printf "%s" "${CBM_BENCH_RUNTIME_ROOT-}"' _ "$HANDOFF")
KEPT_RUNTIME=$(bash -c '. "$1" && printf "%s" "${CBM_RUNTIME_DIR-}"' _ "$HANDOFF")
KEPT_CACHE=$(bash -c '. "$1" && printf "%s" "${CBM_CACHE_DIR-}"' _ "$HANDOFF")
[[ -n "$KEPT_ROOT" && -d "$KEPT_ROOT" && ! -L "$KEPT_ROOT" ]] ||
fail "benchmark-index did not keep its runtime root: ${KEPT_ROOT:-<none>}"
[[ -d "$KEPT_ROOT/cache" && -d "$KEPT_ROOT/runtime" ]] ||
fail "the kept root $KEPT_ROOT lost its cache or runtime directory"
grep -qF -- "${KEPT_CACHE}"$'\t'"${KEPT_RUNTIME}" "$KEEP_LOG" ||
fail "runtime-root.txt does not name the runtime and cache the product processes used"
rm -rf -- "$KEPT_ROOT"
# The handoff promises a stopped daemon, so a kept runtime is handed over only
# once `daemon stop` succeeded. A refused stop fails the run, writes no handoff
# and keeps the root: the daemon may still be using it, so removing it is not
# the harness's call. The refusal itself has to reach the output.
STOP_LOG="$WORKDIR/keep-stop-refused-environment.log"
STOP_HANDOFF="$WORKDIR/results/keep-stop-refused/runtime-root.txt"
stop_rc=0
CBM_CACHE_DIR="$CALLER_CACHE" \
CBM_RUNTIME_DIR="$CALLER_RUNTIME" \
CBM_BENCH_ENV_PROBE="$STOP_LOG" \
CBM_BENCH_PROBE_INDEX_OK=1 \
CBM_BENCH_PROBE_STOP_REFUSED=1 \
CBM_BENCH_KEEP_RUNTIME=1 \
"$ROOT/scripts/benchmark-index.sh" "$ENV_PROBE" keep-stop-refused "$REPO" "$WORKDIR/results" \
> "$WORKDIR/keep-stop-refused.out" 2>&1 || stop_rc=$?
[[ -s "$STOP_LOG" ]] || fail "benchmark-index (keep, refused stop) did not execute the environment-probe fixture"
STOP_RUNTIME=$(normalize_path "$(tail -n 1 "$STOP_LOG" | cut -f2)")
STOP_ROOT="${STOP_RUNTIME%/*}"
stop_root_kept=0
[[ ! -d "$STOP_ROOT/runtime" ]] || stop_root_kept=1
# Removed here, before any verdict, so a failing assertion leaks no root.
case "${STOP_ROOT##*/}" in
cbmrt.?* | cbmrt-?*) rm -rf -- "$STOP_ROOT" ;;
*) fail "benchmark-index (keep, refused stop) used an unexpected private root: $STOP_ROOT" ;;
esac
[[ "$stop_rc" -ne 0 ]] || fail "benchmark-index exited 0 although its daemon refused to stop"
[[ ! -e "$STOP_HANDOFF" ]] || fail "benchmark-index handed over a runtime whose daemon refused to stop"
(( stop_root_kept )) || fail "benchmark-index removed a runtime root whose daemon refused to stop"
grep -q 'probe: daemon NOT stopped' "$WORKDIR/keep-stop-refused.out" ||
fail "benchmark-index did not surface why its daemon refused to stop"
# Asked to keep the runtime and refused the index, the harness has nothing worth
# keeping: the run fails, no root survives, and no handoff is written — nor left
# over from an earlier run, since the evaluation loop reuses the results
# directory.
REFUSED_LOG="$WORKDIR/keep-refused-environment.log"
REFUSED_HANDOFF="$WORKDIR/results/keep-refused/runtime-root.txt"
mkdir -p "${REFUSED_HANDOFF%/*}"
echo 'CBM_BENCH_RUNTIME_ROOT=/stale/root/from/an/earlier/run' > "$REFUSED_HANDOFF"
refused_rc=0
CBM_CACHE_DIR="$CALLER_CACHE" \
CBM_RUNTIME_DIR="$CALLER_RUNTIME" \
CBM_BENCH_ENV_PROBE="$REFUSED_LOG" \
CBM_BENCH_KEEP_RUNTIME=1 \
"$ROOT/scripts/benchmark-index.sh" "$ENV_PROBE" keep-refused "$REPO" "$WORKDIR/results" \
> "$WORKDIR/keep-refused.out" 2>&1 || refused_rc=$?
[[ "$refused_rc" -ne 0 ]] || fail "benchmark-index exited 0 after a refused index it was asked to keep"
for metric in setup-time total-time index-time; do
[[ -s "$WORKDIR/results/keep-refused/$metric.txt" ]] ||
fail "benchmark-index did not record $metric.txt for a refused index"
done
assert_isolated "benchmark-index (keep, refused index)" "$REFUSED_LOG"
[[ ! -e "$REFUSED_HANDOFF" ]] || fail "benchmark-index left a handoff for an index that failed"
# The same holds for a run that never reaches the index: one whose repository
# does not exist fails during setup, and an earlier run's handoff in the reused
# results directory must already be gone by then.
SETUP_HANDOFF="$WORKDIR/results/setup-failed/runtime-root.txt"
mkdir -p "${SETUP_HANDOFF%/*}"
echo 'CBM_BENCH_RUNTIME_ROOT=/stale/root/from/an/earlier/run' > "$SETUP_HANDOFF"
setup_rc=0
CBM_CACHE_DIR="$CALLER_CACHE" \
CBM_RUNTIME_DIR="$CALLER_RUNTIME" \
CBM_BENCH_ENV_PROBE="$WORKDIR/setup-failed-environment.log" \
CBM_BENCH_KEEP_RUNTIME=1 \
"$ROOT/scripts/benchmark-index.sh" "$ENV_PROBE" setup-failed "$WORKDIR/no-such-repo" "$WORKDIR/results" \
> "$WORKDIR/setup-failed.out" 2>&1 || setup_rc=$?
[[ "$setup_rc" -ne 0 ]] || fail "benchmark-index exited 0 for a repository that does not exist"
[[ ! -e "$SETUP_HANDOFF" ]] ||
fail "benchmark-index left an earlier handoff behind after a run that failed during setup"
SEARCH_LOG="$WORKDIR/search-environment.log"
CBM_CACHE_DIR="$CALLER_CACHE" \
CBM_RUNTIME_DIR="$CALLER_RUNTIME" \
CBM_BENCH_ENV_PROBE="$SEARCH_LOG" \
"$ROOT/scripts/benchmark-search-graph.sh" "$ENV_PROBE" "$REPO" \
> "$WORKDIR/search.out" 2>&1 || true
assert_isolated "benchmark-search-graph" "$SEARCH_LOG"
# A refused index must name its cause. The fixture writes one line to stderr and
# exits non-zero; discarding it leaves "did not report a project" as the only
# thing an operator sees.
grep -q -- '--- index/parse stderr ---' "$WORKDIR/search.out" ||
fail "benchmark-search-graph hid the index stderr behind its own message"
grep -q 'probe: index refused' "$WORKDIR/search.out" ||
fail "benchmark-search-graph did not surface the cause of the index failure"
# A private daemon that does not start fails either harness, and the product's
# own explanation has to reach the output: "did not start" alone leaves the
# operator with the symptom only.
for harness in benchmark-index benchmark-search-graph; do
if [[ "$harness" == benchmark-index ]]; then
harness_args=("$ENV_PROBE" start-refused "$REPO" "$WORKDIR/results")
else
harness_args=("$ENV_PROBE" "$REPO")
fi
start_rc=0
CBM_CACHE_DIR="$CALLER_CACHE" \
CBM_RUNTIME_DIR="$CALLER_RUNTIME" \
CBM_BENCH_ENV_PROBE="$WORKDIR/$harness-start-refused-environment.log" \
CBM_BENCH_PROBE_START_REFUSED=1 \
"$ROOT/scripts/$harness.sh" "${harness_args[@]}" \
> "$WORKDIR/$harness-start-refused.out" 2>&1 || start_rc=$?
[[ "$start_rc" -ne 0 ]] || fail "$harness exited 0 although its private daemon did not start"
assert_isolated "$harness (daemon start refused)" "$WORKDIR/$harness-start-refused-environment.log"
grep -q 'probe: daemon start refused' "$WORKDIR/$harness-start-refused.out" ||
fail "$harness did not surface why its private daemon did not start"
done
# The request carrying the repository path has to be built as JSON. A path may
# legitimately contain a quote or a backslash — hand-built JSON turns that into
# a payload the server cannot parse, or one that means something else. NTFS
# rejects both characters in a path component, so this case is POSIX-only.
case "$(uname -s)" in
MINGW* | MSYS* | CYGWIN*) ;;
*)
QUIRKY_REPO="$WORKDIR/re\"po\\dir"
mkdir -p "$QUIRKY_REPO"
echo 'def bench(): return 1' > "$QUIRKY_REPO/bench.py"
QUIRKY_RESOLVED=$(cd "$QUIRKY_REPO" && pwd -P)
REQUEST_LOG="$WORKDIR/requests.log"
CBM_CACHE_DIR="$CALLER_CACHE" \
CBM_RUNTIME_DIR="$CALLER_RUNTIME" \
CBM_BENCH_ENV_PROBE="$WORKDIR/quirky-environment.log" \
CBM_BENCH_REQUEST_LOG="$REQUEST_LOG" \
"$ROOT/scripts/benchmark-search-graph.sh" "$ENV_PROBE" "$QUIRKY_REPO" \
> "$WORKDIR/quirky.out" 2>&1 || true
python3 - "$REQUEST_LOG" "$QUIRKY_RESOLVED" <<'PY' || fail "benchmark-search-graph built an index request that is not valid JSON for a quoted path"
import json
import sys
request_log, expected = sys.argv[1], sys.argv[2]
try:
lines = [line for line in open(request_log).read().splitlines() if line.strip()]
except OSError:
sys.exit("the search benchmark sent no index request")
if not lines:
sys.exit("the search benchmark sent no index request")
payload = json.loads(lines[0])
if payload.get("repo_path") != expected:
sys.exit(f"repo_path is {payload.get('repo_path')!r}, expected {expected!r}")
PY
;;
esac
echo "PASS: benchmark harnesses isolate their daemon runtime and cache from the caller"
tests/test_cli.c
+206 -3
View File
@@ -27,6 +27,7 @@
#include <foundation/platform.h>
#include <foundation/private_file_lock.h>
#include <foundation/sha256.h>
#include <foundation/str_util.h>
#include <mcp/mcp.h>
#include <mcp/index_supervisor.h>
#include <pipeline/pipeline.h>
@@ -12814,9 +12815,91 @@ TEST(cli_hook_unindexed_worktree_reports_no_match_not_silent) {
snprintf(input, sizeof(input), "{\"hook_event_name\":\"SessionStart\",\"cwd\":\"%s\"}", wtdir);
char *wt_out = cbm_hook_augment_lifecycle_json(input);
bool deliberate = wt_out && wt_out[0] && strstr(wt_out, "no indexed graph project matched") &&
!strstr(wt_out, "is indexed");
strstr(wt_out, "Run index_repository") &&
!strstr(wt_out, "ignore_worktrees is enabled") && !strstr(wt_out, "is indexed");
free(wt_out);
/* The hook must read the runtime store. With the key off the note still
* says to index; with it on, the same unindexed worktree must not. */
cbm_config_t *cfg = cbm_config_open(cache);
bool configured = cfg && cbm_config_set(cfg, CBM_CONFIG_IGNORE_WORKTREES, "true") == 0;
cbm_config_close(cfg);
char *ignored_out = configured ? cbm_hook_augment_lifecycle_json(input) : NULL;
bool honored = ignored_out && strstr(ignored_out, "ignore_worktrees is enabled") &&
strstr(ignored_out, "do not run index_repository") &&
!strstr(ignored_out, "is indexed");
free(ignored_out);
/* A symlink to a directory inside that worktree has no lexical .git.
* The hook must still follow the real path and honor ignore_worktrees. */
char alias_target[600];
snprintf(alias_target, sizeof(alias_target), "%s/nested", wtdir);
bool alias_target_ok = test_mkdirp(alias_target) == 0;
char alias[512];
snprintf(alias, sizeof(alias), "%s/wt-alias", tmpdir);
bool alias_made = alias_target_ok && symlink(alias_target, alias) == 0;
snprintf(input, sizeof(input), "{\"hook_event_name\":\"SessionStart\",\"cwd\":\"%s\"}",
alias);
char *alias_out = alias_made ? cbm_hook_augment_lifecycle_json(input) : NULL;
bool alias_ignored = alias_out && strstr(alias_out, "ignore_worktrees is enabled") &&
strstr(alias_out, "do not run index_repository") &&
!strstr(alias_out, "Run index_repository");
free(alias_out);
/* A linked worktree nested inside the indexed checkout must not inherit
* that parent graph once ignore_worktrees is on. */
char insider[512];
snprintf(insider, sizeof(insider), "%s/inside-wt", maindir);
snprintf(cmd, sizeof(cmd), "cd \"%s\" && git worktree add -q \"%s\" -b agl7inside", maindir,
insider);
bool inside_made = configured && system(cmd) == 0;
char inside_sub[600];
snprintf(inside_sub, sizeof(inside_sub), "%s/nested", insider);
bool inside_sub_made = inside_made && test_mkdirp(inside_sub) == 0;
snprintf(input, sizeof(input), "{\"hook_event_name\":\"SessionStart\",\"cwd\":\"%s\"}",
inside_sub);
char *inside_out = inside_sub_made ? cbm_hook_augment_lifecycle_json(input) : NULL;
bool inside_ignored = inside_out && strstr(inside_out, "ignore_worktrees is enabled") &&
strstr(inside_out, "do not run index_repository") &&
!strstr(inside_out, "is indexed") && !strstr(inside_out, main_name);
free(inside_out);
/* Indexing that nested worktree itself must still win over the parent. */
char *inside_name = inside_made ? cbm_project_name_from_path(insider) : NULL;
bool inside_stored = false;
if (inside_name) {
char db_inside[900];
snprintf(db_inside, sizeof(db_inside), "%s/%s.db", cache, inside_name);
cbm_store_t *si = cbm_store_open_path(db_inside);
inside_stored = si && cbm_store_upsert_project(si, inside_name, insider) == CBM_STORE_OK;
if (si)
cbm_store_close(si);
}
char *exact_out = inside_stored ? cbm_hook_augment_lifecycle_json(input) : NULL;
bool exact_kept = exact_out && inside_name && strstr(exact_out, inside_name) &&
strstr(exact_out, "is indexed") &&
!strstr(exact_out, "ignore_worktrees is enabled");
free(exact_out);
/* An unindexed worktree nested inside that indexed worktree must not
* inherit the outer worktree's graph. */
char child[600];
snprintf(child, sizeof(child), "%s/child-wt", insider);
snprintf(cmd, sizeof(cmd), "cd \"%s\" && git worktree add -q \"%s\" -b agl7child", maindir,
child);
bool child_made = inside_stored && system(cmd) == 0;
char child_sub[700];
snprintf(child_sub, sizeof(child_sub), "%s/sub", child);
bool child_sub_made = child_made && test_mkdirp(child_sub) == 0;
snprintf(input, sizeof(input), "{\"hook_event_name\":\"SessionStart\",\"cwd\":\"%s\"}",
child_sub);
char *child_out = child_sub_made ? cbm_hook_augment_lifecycle_json(input) : NULL;
bool child_ignored = child_out && inside_name &&
strstr(child_out, "ignore_worktrees is enabled") &&
strstr(child_out, "do not run index_repository") &&
!strstr(child_out, "is indexed") && !strstr(child_out, inside_name);
free(child_out);
snprintf(input, sizeof(input), "{\"hook_event_name\":\"SessionStart\",\"cwd\":\"%s\"}",
maindir);
char *main_out = cbm_hook_augment_lifecycle_json(input);
@@ -12825,6 +12908,7 @@ TEST(cli_hook_unindexed_worktree_reports_no_match_not_silent) {
restore_test_env("CBM_CACHE_DIR", saved_cache);
free(main_name);
free(inside_name);
snprintf(cmd, sizeof(cmd), "cd \"%s\" && git worktree remove --force \"%s\" >/dev/null 2>&1",
maindir, wtdir);
(void)system(cmd);
@@ -12832,10 +12916,110 @@ TEST(cli_hook_unindexed_worktree_reports_no_match_not_silent) {
if (!deliberate)
FAIL("unindexed worktree must get a deliberate no-match notice, never a silent 0 bytes");
if (!honored)
FAIL("ignore_worktrees in the runtime config must change the unindexed-worktree note");
if (!alias_ignored)
FAIL("a symlink into an ignored worktree must not recommend index_repository");
if (!inside_ignored)
FAIL("a nested linked worktree must not inherit the indexed parent graph");
if (!exact_kept)
FAIL("an exact index of the nested worktree must still be reported");
if (!child_ignored)
FAIL("a worktree nested inside an indexed worktree must not inherit that graph");
if (!main_ok)
FAIL("the indexed main checkout must still resolve in the same matrix");
PASS();
}
/* With ignore_worktrees unset, the lifecycle hook must do what it did before
* the key existed. It may read the key, but it must not create a runtime
* config store just to find the key unset, and it must not canonicalize the
* cwd or probe for a linked worktree. Turning the key on is the positive
* control: the same call then reaches the worktree gate exactly once. */
TEST(cli_hook_ignore_worktrees_default_off_does_no_worktree_work) {
char tmpdir[256];
char *raw = th_mktempdir("cbm_hook_wt_off");
if (!raw)
FAIL("th_mktempdir returned NULL");
snprintf(tmpdir, sizeof(tmpdir), "%s", raw);
char cache[512];
char maindir[512];
char wtdir[512];
char store_path[600];
snprintf(cache, sizeof(cache), "%s/cache", tmpdir);
snprintf(maindir, sizeof(maindir), "%s/checkout-main", tmpdir);
snprintf(wtdir, sizeof(wtdir), "%s/checkout-side", tmpdir);
snprintf(store_path, sizeof(store_path), "%s/" CBM_CONFIG_DB_FILENAME, cache);
test_mkdirp(cache);
test_mkdirp(maindir);
char cmd[2048];
snprintf(cmd, sizeof(cmd),
"cd \"%s\" && git init -q && git config user.email t@t && git config user.name t && "
": > f.txt && git add f.txt && git commit -qm init && "
"git worktree add -q \"%s\" -b wtoff",
maindir, wtdir);
if (system(cmd) != 0) {
th_rmtree(tmpdir);
SKIP_PLATFORM("git worktree add unavailable");
}
char *saved_cache = save_test_env("CBM_CACHE_DIR");
cbm_setenv("CBM_CACHE_DIR", cache, 1);
char input[1024];
snprintf(input, sizeof(input), "{\"hook_event_name\":\"SessionStart\",\"cwd\":\"%s\"}", wtdir);
struct stat st;
int gate_calls = 0;
cbm_hook_set_worktree_gate_counter_for_testing(&gate_calls);
bool store_absent_before = stat(store_path, &st) != 0;
char *off_out = cbm_hook_augment_lifecycle_json(input);
bool off_note = off_out && strstr(off_out, "Run index_repository") &&
!strstr(off_out, "ignore_worktrees is enabled");
free(off_out);
bool store_absent_after = stat(store_path, &st) != 0;
int off_gate_calls = gate_calls;
/* A store that leaves the key unset may be read for the key, nothing more. */
cbm_config_t *cfg = cbm_config_open(cache);
bool other_key_set = cfg && cbm_config_set(cfg, CBM_CONFIG_AUTO_WATCH, "true") == 0;
cbm_config_close(cfg);
gate_calls = 0;
char *unset_out = other_key_set ? cbm_hook_augment_lifecycle_json(input) : NULL;
bool unset_note = unset_out && strstr(unset_out, "Run index_repository") &&
!strstr(unset_out, "ignore_worktrees is enabled");
free(unset_out);
int unset_gate_calls = gate_calls;
cfg = cbm_config_open(cache);
bool enabled = cfg && cbm_config_set(cfg, CBM_CONFIG_IGNORE_WORKTREES, "true") == 0;
cbm_config_close(cfg);
gate_calls = 0;
char *on_out = enabled ? cbm_hook_augment_lifecycle_json(input) : NULL;
bool on_note = on_out && strstr(on_out, "ignore_worktrees is enabled");
free(on_out);
int on_gate_calls = gate_calls;
cbm_hook_set_worktree_gate_counter_for_testing(NULL);
restore_test_env("CBM_CACHE_DIR", saved_cache);
snprintf(cmd, sizeof(cmd), "cd \"%s\" && git worktree remove --force \"%s\" >/dev/null 2>&1",
maindir, wtdir);
(void)system(cmd);
th_rmtree(tmpdir);
ASSERT_TRUE(store_absent_before);
ASSERT_TRUE(off_note);
if (!store_absent_after)
FAIL("a default-off lifecycle event must not create the runtime config store");
ASSERT_EQ(off_gate_calls, 0);
ASSERT_TRUE(other_key_set);
ASSERT_TRUE(unset_note);
ASSERT_EQ(unset_gate_calls, 0);
ASSERT_TRUE(enabled);
ASSERT_TRUE(on_note);
ASSERT_EQ(on_gate_calls, 1);
PASS();
}
#endif
TEST(cli_hook_session_sanitizes_untrusted_project_metadata) {
@@ -15309,14 +15493,18 @@ TEST(cli_hook_augment_subagent_tier_router_contract) {
}
TEST(cli_hook_augment_subagent_no_project_guidance_is_read_only) {
const char *session = cbm_hook_no_project_index_guidance_for_testing("SessionStart");
const char *subagent = cbm_hook_no_project_index_guidance_for_testing("SubagentStart");
const char *session = cbm_hook_no_project_index_guidance_for_testing("SessionStart", false);
const char *subagent = cbm_hook_no_project_index_guidance_for_testing("SubagentStart", false);
const char *worktree = cbm_hook_no_project_index_guidance_for_testing("SessionStart", true);
ASSERT_NOT_NULL(session);
ASSERT_NOT_NULL(subagent);
ASSERT_NOT_NULL(worktree);
ASSERT(strstr(session, "Run index_repository") != NULL);
ASSERT(strstr(subagent, "Ask the parent agent to run index_repository") != NULL);
ASSERT(strstr(subagent, "do not attempt graph mutation") != NULL);
ASSERT(strstr(subagent, "Run index_repository") == NULL);
ASSERT(strstr(worktree, "ignore_worktrees is enabled") != NULL);
ASSERT(strstr(worktree, "do not run index_repository") != NULL);
PASS();
}
@@ -19419,6 +19607,19 @@ TEST(cli_ui_config_keys_are_discoverable_and_settable_issue1558) {
PASS();
}
TEST(cli_ignore_worktrees_config_key_is_discoverable) {
bool listed = false;
for (size_t i = 0; i < cbm_cli_config_key_count_for_testing(); i++) {
const char *key = cbm_cli_config_key_at_for_testing(i);
if (key && strcmp(key, CBM_CONFIG_IGNORE_WORKTREES) == 0) {
listed = true;
break;
}
}
ASSERT_TRUE(listed);
PASS();
}
TEST(cli_skill_frontmatter_scalars_with_colons_are_quoted_issue1554) {
const cbm_skill_t *sk = cbm_get_skills();
ASSERT_NOT_NULL(sk);
@@ -20302,6 +20503,7 @@ SUITE(cli) {
RUN_TEST(cli_update_download_failure_does_not_quiesce_sessions);
RUN_TEST(cli_update_already_current_does_not_quiesce_sessions);
RUN_TEST(cli_ui_config_keys_are_discoverable_and_settable_issue1558);
RUN_TEST(cli_ignore_worktrees_config_key_is_discoverable);
RUN_TEST(cli_skill_frontmatter_scalars_with_colons_are_quoted_issue1554);
RUN_TEST(cli_external_manager_detection_needs_positive_evidence_issue1566);
RUN_TEST(cli_install_managed_binary_config_path_issue2722);
@@ -20544,6 +20746,7 @@ SUITE(cli) {
#ifndef _WIN32
RUN_TEST(cli_hook_worktree_cwd_resolves_own_indexed_project);
RUN_TEST(cli_hook_unindexed_worktree_reports_no_match_not_silent);
RUN_TEST(cli_hook_ignore_worktrees_default_off_does_no_worktree_work);
#endif
RUN_TEST(cli_hook_session_sanitizes_untrusted_project_metadata);
RUN_TEST(cli_hook_session_untrusted_label_covers_project_name_only);
tests/test_daemon_ipc.c
+218
View File
@@ -3581,6 +3581,222 @@ TEST(daemon_ipc_posix_lifetime_reservation_rejects_fork_inheritance) {
PASS();
}
static bool ipc_test_lifetime_lock_path(char out[TEST_PATH_CAP], const char *runtime_dir,
const char *key) {
int written = runtime_dir && key
? snprintf(out, TEST_PATH_CAP, "%s/cbm-%s.lifetime.lock", runtime_dir, key)
: -1;
return written > 0 && written < TEST_PATH_CAP;
}
/* Child-process verdict on whether the lifetime lock at lock_path is held by
* someone else, going straight through open()/fcntl() rather than any of
* this codebase's APIs, so a genuinely separate process cannot inherit the
* parent's in-process claim registry. Distinguishes three outcomes instead
* of collapsing "held" and "could not even check" into the same value:
* IPC_TEST_LOCK_HELD only when open() succeeded and F_SETLK failed with
* EACCES or EAGAIN (the lock is held by another process, as expected);
* IPC_TEST_LOCK_TAKEN when F_SETLK succeeded (the lock was free, a bug);
* IPC_TEST_LOCK_ERROR for anything else (open() failed, e.g. a wrong path,
* or F_SETLK failed with an errno that says nothing about the lock's
* state), which must never be mistaken for IPC_TEST_LOCK_HELD. */
enum {
IPC_TEST_LOCK_HELD = 0,
IPC_TEST_LOCK_TAKEN = 1,
IPC_TEST_LOCK_ERROR = 3,
};
static uint8_t ipc_test_lock_child_verdict(const char *lock_path) {
int fd = open(lock_path, O_RDWR);
if (fd < 0) {
return IPC_TEST_LOCK_ERROR;
}
struct flock record_lock = {
.l_type = F_WRLCK,
.l_whence = SEEK_SET,
.l_start = 0,
.l_len = 0,
};
int lock_result;
do {
lock_result = fcntl(fd, F_SETLK, &record_lock);
} while (lock_result != 0 && errno == EINTR);
int lock_errno = errno;
(void)close(fd);
if (lock_result == 0) {
return IPC_TEST_LOCK_TAKEN;
}
return lock_errno == EACCES || lock_errno == EAGAIN ? IPC_TEST_LOCK_HELD : IPC_TEST_LOCK_ERROR;
}
TEST(daemon_ipc_posix_lifetime_reservation_probe_does_not_drop_held_lock) {
static const char key[] = "c1c1d2d2e3e3f4f4";
char parent[TEST_PATH_CAP] = {0};
char runtime_dir[TEST_PATH_CAP] = {0};
char lock_path[TEST_PATH_CAP] = {0};
cbm_daemon_ipc_endpoint_t *endpoint = NULL;
cbm_daemon_ipc_lifetime_reservation_t *reservation = NULL;
int result_pipe[2] = {-1, -1};
pid_t child = -1;
uint8_t child_result = 0;
int child_status = -1;
int acquired = -1;
int held_after_first_probe = -1;
int held_after_second_probe = -1;
int free_after_release = -1;
bool lock_path_ok = false;
if (ipc_test_parent_new(parent, "probe-holds-lock")) {
endpoint = cbm_daemon_ipc_endpoint_new(key, parent);
}
if (endpoint) {
ipc_test_copy_path(runtime_dir, cbm_daemon_ipc_endpoint_runtime_dir(endpoint));
lock_path_ok = ipc_test_lifetime_lock_path(lock_path, runtime_dir, key);
acquired = cbm_daemon_ipc_lifetime_reservation_try_acquire(endpoint, &reservation);
}
if (reservation) {
/* Two probes, matching how a real daemon polls its own reservation
* repeatedly while running. Each probe of an already-held lock used
* to open a throwaway fd on the lock file and close it. Since
* fcntl(2) record locks are scoped to (process, inode), that close
* silently released the real lock every time, regardless of the
* still-open fd the reservation itself is holding. */
held_after_first_probe = cbm_daemon_ipc_lifetime_reservation_probe(endpoint);
held_after_second_probe = cbm_daemon_ipc_lifetime_reservation_probe(endpoint);
}
if (reservation && lock_path_ok && pipe(result_pipe) == 0) {
child = fork();
}
if (child == 0) {
/* A genuinely independent process, not going through any of this
* codebase's APIs so it cannot inherit the parent's in-process
* claim registry: try to take the real OS-level lock directly. If
* the parent's fcntl lock survived the probes above, this fails. */
(void)close(result_pipe[0]);
child_result = ipc_test_lock_child_verdict(lock_path);
bool reported = ipc_test_fd_write_all(result_pipe[1], &child_result, sizeof(child_result));
(void)close(result_pipe[1]);
_exit(reported ? 0 : 1);
}
if (child > 0) {
(void)close(result_pipe[1]);
result_pipe[1] = -1;
bool received = ipc_test_fd_read_all(result_pipe[0], &child_result, sizeof(child_result));
(void)close(result_pipe[0]);
result_pipe[0] = -1;
if (!received) {
child_result = 2;
}
while (waitpid(child, &child_status, 0) < 0 && errno == EINTR) {}
}
cbm_daemon_ipc_lifetime_reservation_release(reservation);
if (endpoint) {
free_after_release = cbm_daemon_ipc_lifetime_reservation_probe(endpoint);
}
for (size_t index = 0; index < 2; index++) {
if (result_pipe[index] >= 0) {
(void)close(result_pipe[index]);
}
}
cbm_daemon_ipc_endpoint_free(endpoint);
ipc_test_remove_tree(runtime_dir, parent);
ASSERT_EQ(acquired, 1);
ASSERT_TRUE(lock_path_ok);
ASSERT_EQ(held_after_first_probe, 1);
ASSERT_EQ(held_after_second_probe, 1);
ASSERT_GT(child, 0);
ASSERT_TRUE(WIFEXITED(child_status));
ASSERT_EQ(WEXITSTATUS(child_status), 0);
ASSERT_EQ(child_result, IPC_TEST_LOCK_HELD);
ASSERT_EQ(free_after_release, 0);
PASS();
}
TEST(daemon_ipc_posix_lifetime_reservation_try_acquire_again_does_not_drop_held_lock) {
static const char key[] = "a1a1b2b2c3c3d4d4";
char parent[TEST_PATH_CAP] = {0};
char runtime_dir[TEST_PATH_CAP] = {0};
char lock_path[TEST_PATH_CAP] = {0};
cbm_daemon_ipc_endpoint_t *endpoint = NULL;
cbm_daemon_ipc_lifetime_reservation_t *reservation = NULL;
cbm_daemon_ipc_lifetime_reservation_t *second_reservation =
(cbm_daemon_ipc_lifetime_reservation_t *)(uintptr_t)1;
int result_pipe[2] = {-1, -1};
pid_t child = -1;
uint8_t child_result = 0;
int child_status = -1;
int acquired = -1;
int reacquired = -1;
int free_after_release = -1;
bool lock_path_ok = false;
if (ipc_test_parent_new(parent, "try-acquire-again-holds-lock")) {
endpoint = cbm_daemon_ipc_endpoint_new(key, parent);
}
if (endpoint) {
ipc_test_copy_path(runtime_dir, cbm_daemon_ipc_endpoint_runtime_dir(endpoint));
lock_path_ok = ipc_test_lifetime_lock_path(lock_path, runtime_dir, key);
acquired = cbm_daemon_ipc_lifetime_reservation_try_acquire(endpoint, &reservation);
}
if (reservation) {
/* This process already holds the lifetime lock. Calling try_acquire
* again, still in this process, must trust the in-process registry
* alone and return 0 (already held, nothing new to hand back)
* without touching the lock file: opening and closing a second fd
* on it would drop the fcntl(2) record lock this process already
* holds, exactly the way the probe's own fast path used to. */
reacquired = cbm_daemon_ipc_lifetime_reservation_try_acquire(endpoint, &second_reservation);
}
if (reservation && lock_path_ok && pipe(result_pipe) == 0) {
child = fork();
}
if (child == 0) {
/* A genuinely independent process, not going through any of this
* codebase's APIs so it cannot inherit the parent's in-process
* claim registry: try to take the real OS-level lock directly. If
* the repeated try_acquire above survived, this fails. */
(void)close(result_pipe[0]);
child_result = ipc_test_lock_child_verdict(lock_path);
bool reported = ipc_test_fd_write_all(result_pipe[1], &child_result, sizeof(child_result));
(void)close(result_pipe[1]);
_exit(reported ? 0 : 1);
}
if (child > 0) {
(void)close(result_pipe[1]);
result_pipe[1] = -1;
bool received = ipc_test_fd_read_all(result_pipe[0], &child_result, sizeof(child_result));
(void)close(result_pipe[0]);
result_pipe[0] = -1;
if (!received) {
child_result = 2;
}
while (waitpid(child, &child_status, 0) < 0 && errno == EINTR) {}
}
cbm_daemon_ipc_lifetime_reservation_release(reservation);
if (endpoint) {
free_after_release = cbm_daemon_ipc_lifetime_reservation_probe(endpoint);
}
for (size_t index = 0; index < 2; index++) {
if (result_pipe[index] >= 0) {
(void)close(result_pipe[index]);
}
}
cbm_daemon_ipc_endpoint_free(endpoint);
ipc_test_remove_tree(runtime_dir, parent);
ASSERT_EQ(acquired, 1);
ASSERT_TRUE(lock_path_ok);
ASSERT_EQ(reacquired, 0);
ASSERT_TRUE(second_reservation == NULL);
ASSERT_GT(child, 0);
ASSERT_TRUE(WIFEXITED(child_status));
ASSERT_EQ(WEXITSTATUS(child_status), 0);
ASSERT_EQ(child_result, IPC_TEST_LOCK_HELD);
ASSERT_EQ(free_after_release, 0);
PASS();
}
TEST(daemon_ipc_posix_child_participant_handoff_retains_legacy_bridge) {
#ifdef _WIN32
PASS();
@@ -5999,6 +6215,8 @@ SUITE(daemon_ipc) {
#endif
RUN_TEST(daemon_ipc_posix_startup_lock_is_cross_process);
RUN_TEST(daemon_ipc_posix_lifetime_reservation_rejects_fork_inheritance);
RUN_TEST(daemon_ipc_posix_lifetime_reservation_probe_does_not_drop_held_lock);
RUN_TEST(daemon_ipc_posix_lifetime_reservation_try_acquire_again_does_not_drop_held_lock);
RUN_TEST(daemon_ipc_posix_child_participant_handoff_retains_legacy_bridge);
RUN_TEST(daemon_ipc_posix_publication_boundaries_recover_from_crash);
RUN_TEST(daemon_ipc_posix_record_publication_windows_recover_from_crash);
tests/test_edge_structural.c
+20 -2
View File
@@ -826,14 +826,31 @@ TEST(es_decorates_attribute_csharp) {
* resolves in the registry. pass_usages.c handles this.
* ══════════════════════════════════════════════════════════════════ */
/* Python constructor syntax is a CALLS edge to the materialized Class node. */
/* Python ClassName() with a user __init__ is a CALLS edge to that method.
* The Class node no longer receives the instantiation edge. A class with no
* user __init__ still targets the Class (lsp_constructor). */
TEST(es_usage_crossfile_python) {
static const ES_LangFile f[] = {
{"models.py",
"class User:\n def __init__(self, name):\n self.name = name\n"},
{"main.py",
"from .models import User\n\n\ndef create_user(name):\n return User(name)\n"}};
ASSERT_EQ(es_exact_edge_by_name(f, 2, "CALLS", "create_user", "User"), 1);
ASSERT_EQ(es_exact_edge_by_name(f, 2, "CALLS", "create_user", "__init__"), 1);
ASSERT_EQ(es_exact_edge_by_name(f, 2, "CALLS", "create_user", "User"), 0);
PASS();
}
/* Issue #1642 repro: build() -> Embedder.__init__, not the Embedder class. */
TEST(es_calls_python_constructor_init) {
static const ES_LangFile f[] = {
{"main.py", "class Embedder:\n"
" def __init__(self, model=\"x\"):\n"
" self.model = model\n"
"\n"
"def build():\n"
" return Embedder(model=\"y\")\n"}};
ASSERT_EQ(es_exact_edge_by_name(f, 1, "CALLS", "build", "__init__"), 1);
ASSERT_EQ(es_exact_edge_by_name(f, 1, "CALLS", "build", "Embedder"), 0);
PASS();
}
@@ -982,6 +999,7 @@ SUITE(edge_structural) {
/* ── FAMILY 7: USAGE cross-file ─────────────────────────── */
/* Uncertain: depends on USAGE extraction for each language. */
RUN_TEST(es_usage_crossfile_python);
RUN_TEST(es_calls_python_constructor_init);
RUN_TEST(es_usage_crossfile_typescript);
RUN_TEST(es_usage_crossfile_go);
tests/test_extraction.c
+173
View File
@@ -6770,6 +6770,177 @@ TEST(extract_ts_nestjs_controller_routes_issue1428) {
PASS();
}
/* #759: the one definition named `name`; NULL for none or more than one. */
static const CBMDefinition *nextjs_only_def(CBMFileResult *r, const char *name) {
const CBMDefinition *found = NULL;
for (int i = 0; i < r->defs.count; i++) {
if (r->defs.items[i].name && strcmp(r->defs.items[i].name, name) == 0) {
if (found) {
return NULL;
}
found = &r->defs.items[i];
}
}
return found;
}
/* #759: a Next.js App Router route file's exported HTTP verb handlers are the
* Functions extraction already makes for them, now carrying the route path of
* the file's directories -- `[id]` as `:id`, `[...slug]` as `*slug`, a
* `(group)` adding nothing -- and the verb as their method. A local
* declaration exported by name (`export { GET }`) is that same Function; no
* second definition appears. The 255-byte path is the longest that fits. */
TEST(extract_nextjs_route_metadata_contract_issue759) {
char long_file[CBM_SZ_512];
char long_path[CBM_SZ_256];
char segment[CBM_SZ_256];
memset(segment, 'x', CBM_SZ_256 - PAIR_LEN);
segment[CBM_SZ_256 - PAIR_LEN] = '\0';
snprintf(long_file, sizeof(long_file), "app/%s/route.ts", segment);
snprintf(long_path, sizeof(long_path), "/%s", segment);
static const char verbs_src[] = "export async function GET() {}\n"
"export async function POST() {}\n"
"export function PUT() {}\n"
"export function PATCH() {}\n"
"export function DELETE() {}\n"
"export function HEAD() {}\n"
"export function OPTIONS() {}\n";
const struct {
const char *file;
const char *src;
const char *path;
const char *names[CBM_SZ_8];
} cases[] = {
{"src/app/api/users/[id]/route.ts",
"export function GET() { return 1; }\nexport const POST = async () => 2;\n",
"/api/users/:id",
{"GET", "POST"}},
{"app/api/verbs/route.ts",
verbs_src,
"/api/verbs",
{"GET", "POST", "PUT", "PATCH", "DELETE", "HEAD", "OPTIONS"}},
{"src/app/(public)/api/[org]/users/[id]/route.ts",
"export async function GET() { return 1; }\n",
"/api/:org/users/:id",
{"GET"}},
{"app/api/[...slug]/route.ts", "export function GET() {}\n", "/api/*slug", {"GET"}},
{"app/api/typed/route.ts",
"type Handler = () => Promise<number>;\nexport const GET: Handler = async () => 1;\n",
"/api/typed",
{"GET"}},
{"app/route.js", "export function GET() { return 1; }\n", "/", {"GET"}},
{"app/api/local/route.ts",
"function GET() { return 1; }\nconst POST = async () => 2;\nexport { GET, POST };\n",
"/api/local",
{"GET", "POST"}},
{long_file, "export function GET() {}\n", long_path, {"GET"}},
};
for (size_t c = 0; c < sizeof(cases) / sizeof(cases[0]); c++) {
CBMLanguage lang = strstr(cases[c].file, ".js") ? CBM_LANG_JAVASCRIPT : CBM_LANG_TYPESCRIPT;
CBMFileResult *r = extract(cases[c].src, lang, "t", cases[c].file);
ASSERT_NOT_NULL(r);
ASSERT_FALSE(r->has_error);
int routed = 0;
for (int i = 0; i < r->defs.count; i++) {
routed += r->defs.items[i].route_path != NULL;
}
int want = 0;
for (; want < CBM_SZ_8 && cases[c].names[want]; want++) {
const CBMDefinition *d = nextjs_only_def(r, cases[c].names[want]);
ASSERT_NOT_NULL(d);
ASSERT_STR_EQ(d->label, "Function");
ASSERT_STR_EQ(d->file_path, cases[c].file);
ASSERT_NOT_NULL(d->route_path);
ASSERT_STR_EQ(d->route_path, cases[c].path);
ASSERT_STR_EQ(d->route_method, cases[c].names[want]);
}
ASSERT_EQ(routed, want);
cbm_free_result(r);
}
PASS();
}
/* #759: nothing else routes. Not a route file, or a directory the route path
* cannot spell -- an optional catch-all, a private folder, a parallel slot,
* an intercepting route, a malformed bracket, a workspace package root, a path
* past 255 bytes. Not a runtime export of an HTTP verb Function of this file:
* an unexported, default, type-only or nested GET, a class method, a
* constant, a lower-case verb; and no handler is made up for a renamed,
* re-exported, wrapped or destructured export, or a `function` expression
* bound to a const: none of them has a Function of its own here. */
TEST(extract_nextjs_rejects_nonroutes_issue759) {
char long_file[CBM_SZ_512];
char segment[CBM_SZ_256];
memset(segment, 'x', CBM_SZ_256 - SKIP_ONE);
segment[CBM_SZ_256 - SKIP_ONE] = '\0';
snprintf(long_file, sizeof(long_file), "app/%s/route.ts", segment);
const char *files[] = {
"pages/api/route.ts",
"app/api/page.ts",
"app/api/route.test.ts",
"app/api/view/route.tsx",
"app/api/view/route.jsx",
"app/api/module/route.mjs",
"app/_private/route.ts",
"src/app/api/_lib/route.ts",
"app/@modal/route.ts",
"app/(.)photo/route.ts",
"app/(..)(..)photo/route.ts",
"app/api/[[...opt]]/route.ts",
"app/api/[broken/route.ts",
"app/api/broken]/route.ts",
"app/api/[]/route.ts",
"app/api/[...]/route.ts",
"app/api/a[id]/route.ts",
"app/()/route.ts",
"apps/web/app/api/route.ts",
long_file,
};
const struct {
const char *file;
const char *src;
} sources[] = {
{"app/api/nonexports/route.ts", "function GET() {}\n"
"export default function POST() {}\n"
"function PUT() {}\n"
"export type { PUT };\n"
"function OPTIONS() {}\n"
"export { type OPTIONS };\n"
"export class Handlers { PATCH() {} }\n"
"export const DELETE = 42;\n"
"export function get() {}\n"
"export function helper() { function HEAD() {} }\n"},
{"app/api/bindings/route.ts", "const handler = async () => 1;\n"
"export { handler as GET };\n"
"export { POST } from './impl';\n"
"export const PUT = wrap(handler);\n"
"export const DELETE = function () {};\n"
"export const { PATCH } = handlers;\n"
"export const HEAD = handler as Handler;\n"
"export const OPTIONS = (async () => 1) satisfies Handler;\n"
"export * from './all';\n"},
};
const int file_count = (int)(sizeof(files) / sizeof(files[0]));
const int source_count = (int)(sizeof(sources) / sizeof(sources[0]));
for (int c = 0; c < file_count + source_count; c++) {
bool by_file = c < file_count;
const char *file = by_file ? files[c] : sources[c - file_count].file;
CBMFileResult *r =
extract(by_file ? "export function GET() {}\n" : sources[c - file_count].src,
CBM_LANG_TYPESCRIPT, "t", file);
ASSERT_NOT_NULL(r);
ASSERT_FALSE(r->has_error);
if (by_file) {
ASSERT_NOT_NULL(nextjs_only_def(r, "GET"));
}
for (int i = 0; i < r->defs.count; i++) {
ASSERT_NULL(r->defs.items[i].route_path);
}
cbm_free_result(r);
}
PASS();
}
/* Return the file's Module definition (extraction pushes it first), or NULL. */
static const CBMDefinition *find_module_def(CBMFileResult *r) {
for (int i = 0; i < r->defs.count; i++) {
@@ -14934,6 +15105,8 @@ SUITE(extraction) {
RUN_TEST(extract_java_jaxrs_empty_path_means_class_path);
RUN_TEST(extract_java_spring_relative_string_not_route_path);
RUN_TEST(extract_ts_nestjs_controller_routes_issue1428);
RUN_TEST(extract_nextjs_route_metadata_contract_issue759);
RUN_TEST(extract_nextjs_rejects_nonroutes_issue759);
RUN_TEST(extract_blazor_page_directive_routes_component);
RUN_TEST(extract_blazor_component_without_page_has_no_route);
RUN_TEST(extract_razor_page_directive_routes_cshtml_view);
tests/test_git_context.c
+470 -1
View File
@@ -10,7 +10,9 @@
*
* The canonical_root tests shell out to `git`, so they SKIP_PLATFORM on
* Windows (the CI shell there cannot init a repo via system()). The root-path
* existence test runs on every platform.
* existence test runs on every platform. The bounded worktree-status tests
* below shell out through cbm_popen instead, so they run on every platform
* that has git on PATH.
*
* Reproduce-first guard: canonical_root_subdir is the genuine RED-without-the-fix
* guard — a repo indexed from a subdirectory yields a relative --git-common-dir
@@ -346,6 +348,95 @@ TEST(canonical_root_linked_worktree) {
#endif /* _WIN32 */
}
/* ── cbm_git_is_linked_worktree ─────────────────────────────────── */
/* Detection backing the `ignore_worktrees` config gate. The predicate must be
* TRUE only for a linked worktree (`git worktree add`) — never for the main
* checkout, a plain directory, or a submodule. The submodule case is the one a
* naive "is .git a regular file?" check gets wrong: a submodule's .git is also a
* gitlink file, and it is separated here by the absence of a `commondir` entry
* in the pointed-at gitdir. */
TEST(is_linked_worktree_true_for_linked_worktree) {
#ifdef _WIN32
SKIP_PLATFORM("git worktree test not implemented for Windows");
#else
/* th_mktempdir() returns a static buffer — copy before the second call. */
char main_tmp[256];
char *raw = th_mktempdir("cbm_wt_main");
if (!raw) FAIL("th_mktempdir returned NULL");
strncpy(main_tmp, raw, sizeof(main_tmp) - 1);
main_tmp[sizeof(main_tmp) - 1] = '\0';
char wt_tmp[256];
raw = th_mktempdir("cbm_wt_linked");
if (!raw) FAIL("th_mktempdir returned NULL");
strncpy(wt_tmp, raw, sizeof(wt_tmp) - 1);
wt_tmp[sizeof(wt_tmp) - 1] = '\0';
th_rmtree(wt_tmp); /* git worktree add creates it */
if (make_git_repo(main_tmp) != 0) {
th_rmtree(main_tmp);
SKIP_PLATFORM("git not available to init a repo");
}
if (git_run(main_tmp, "branch wt-branch") != 0) {
th_rmtree(main_tmp);
FAIL("failed to create branch for worktree");
}
char wt_cmd[1024];
snprintf(wt_cmd, sizeof(wt_cmd), "worktree add \"%s\" wt-branch", wt_tmp);
if (git_run(main_tmp, wt_cmd) != 0) {
th_rmtree(wt_tmp);
th_rmtree(main_tmp);
SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");
}
bool worktree_detected = cbm_git_is_linked_worktree(wt_tmp);
/* A subdirectory has no .git of its own. The predicate must still see the
* linked worktree above it, or ignore_worktrees misses nested sessions. */
char nested[1024];
snprintf(nested, sizeof(nested), "%s/nested/deeper", wt_tmp);
bool nested_ok = th_mkdir_p(nested) == 0;
bool nested_detected = nested_ok && cbm_git_is_linked_worktree(nested);
/* The MAIN checkout of the very same repo must NOT be flagged — otherwise
* enabling ignore_worktrees would stop indexing ordinary repositories. */
bool main_detected = cbm_git_is_linked_worktree(main_tmp);
char main_nested[1024];
snprintf(main_nested, sizeof(main_nested), "%s/src", main_tmp);
bool main_nested_ok = th_mkdir_p(main_nested) == 0;
bool main_nested_detected = main_nested_ok && cbm_git_is_linked_worktree(main_nested);
/* A worktree nested inside another must not share the parent's anchor. */
char inner[1024];
snprintf(inner, sizeof(inner), "%s/inner-wt", wt_tmp);
char inner_cmd[1200];
snprintf(inner_cmd, sizeof(inner_cmd), "worktree add -b inner-branch \"%s\"", inner);
bool inner_added = git_run(main_tmp, inner_cmd) == 0;
char inner_sub[1200];
snprintf(inner_sub, sizeof(inner_sub), "%s/sub", inner);
bool inner_sub_ok = inner_added && th_mkdir_p(inner_sub) == 0;
bool same_outer = cbm_git_same_linked_worktree(nested, wt_tmp);
bool same_inner = inner_sub_ok && cbm_git_same_linked_worktree(inner_sub, inner);
bool not_parent = inner_sub_ok && !cbm_git_same_linked_worktree(inner_sub, wt_tmp);
bool not_main = !cbm_git_same_linked_worktree(nested, main_tmp);
git_run(main_tmp, "worktree prune");
th_rmtree(main_tmp);
th_rmtree(wt_tmp);
ASSERT(worktree_detected);
ASSERT(nested_ok);
ASSERT(nested_detected);
ASSERT(!main_detected);
ASSERT(main_nested_ok);
ASSERT(!main_nested_detected);
ASSERT(inner_added);
ASSERT(same_outer);
ASSERT(same_inner);
ASSERT(not_parent);
ASSERT(not_main);
PASS();
#endif /* _WIN32 */
}
TEST(git_context_ignores_inherited_repo_env) {
#ifdef _WIN32
SKIP_PLATFORM("git-based env-isolation test not supported on Windows CI");
@@ -403,6 +494,68 @@ TEST(git_context_ignores_inherited_repo_env) {
#endif /* _WIN32 */
}
TEST(is_linked_worktree_false_for_submodule_and_nongit) {
#ifdef _WIN32
SKIP_PLATFORM("git worktree test not implemented for Windows");
#else
char super_tmp[256];
char *raw = th_mktempdir("cbm_wt_super");
if (!raw) FAIL("th_mktempdir returned NULL");
strncpy(super_tmp, raw, sizeof(super_tmp) - 1);
super_tmp[sizeof(super_tmp) - 1] = '\0';
char child_tmp[256];
raw = th_mktempdir("cbm_wt_child");
if (!raw) FAIL("th_mktempdir returned NULL");
strncpy(child_tmp, raw, sizeof(child_tmp) - 1);
child_tmp[sizeof(child_tmp) - 1] = '\0';
if (make_git_repo(super_tmp) != 0 || make_git_repo(child_tmp) != 0) {
th_rmtree(super_tmp);
th_rmtree(child_tmp);
SKIP_PLATFORM("git not available to init a repo");
}
/* A plain directory that is not a git repo at all. */
char plain[1024];
snprintf(plain, sizeof(plain), "%s/plain", super_tmp);
if (th_mkdir_p(plain) != 0) {
th_rmtree(super_tmp);
th_rmtree(child_tmp);
FAIL("failed to create plain dir");
}
bool plain_detected = cbm_git_is_linked_worktree(plain);
/* file:// submodules are refused by default since the CVE-2022-39253 fix. */
char sub_cmd[1024];
snprintf(sub_cmd, sizeof(sub_cmd),
"-c protocol.file.allow=always submodule add -q \"%s\" subm", child_tmp);
int sub_rc = git_run(super_tmp, sub_cmd);
char subm[1024];
snprintf(subm, sizeof(subm), "%s/subm", super_tmp);
bool submodule_detected = sub_rc == 0 && cbm_git_is_linked_worktree(subm);
char sub_nested[1024];
snprintf(sub_nested, sizeof(sub_nested), "%s/nested", subm);
bool sub_nested_made = sub_rc == 0 && th_mkdir_p(sub_nested) == 0;
bool sub_nested_detected = sub_nested_made && cbm_git_is_linked_worktree(sub_nested);
th_rmtree(super_tmp);
th_rmtree(child_tmp);
ASSERT(!plain_detected);
if (sub_rc != 0) {
SKIP_PLATFORM("git submodule add unavailable in this environment");
}
/* A submodule gitlink has no commondir, including a subdirectory which
* must not walk into the superproject. */
ASSERT(!submodule_detected);
ASSERT(sub_nested_made);
ASSERT(!sub_nested_detected);
PASS();
#endif /* _WIN32 */
}
TEST(githistory_ignores_inherited_repo_env) {
#ifdef _WIN32
SKIP_PLATFORM("git-based env-isolation test not supported on Windows CI");
@@ -495,6 +648,312 @@ TEST(git_branch_resolve_matches_full_context) {
#endif /* _WIN32 */
}
/* The freshness verdict reads this snapshot, so an inherited GIT_DIR /
* GIT_WORK_TREE pointing at a dirty decoy must not make a clean fixture
* report the decoy's changes as its own (#2003). */
TEST(worktree_status_ignores_inherited_repo_env) {
#ifdef _WIN32
SKIP_PLATFORM("git-based env-isolation test not supported on Windows CI");
#else
char root[256];
char *raw = th_mktempdir("cbm_gitenv_status");
if (!raw)
FAIL("th_mktempdir returned NULL");
snprintf(root, sizeof(root), "%s", raw);
if (make_env_isolation_tree(root) != 0) {
th_rmtree(root);
SKIP_PLATFORM("git not available to init a repo");
}
char decoy[512], fixture[512], path[600];
snprintf(decoy, sizeof(decoy), "%s/decoy", root);
snprintf(fixture, sizeof(fixture), "%s/fixture", root);
/* Dirty only the decoy: one tracked edit and one untracked file. */
snprintf(path, sizeof(path), "%s/a.go", decoy);
th_write_file(path, "package a // dirty\n");
snprintf(path, sizeof(path), "%s/untracked.go", decoy);
th_write_file(path, "package a\n");
git_env_snapshot_t snap;
git_env_hook_enter(&snap, decoy);
cbm_worktree_status_t st;
int rc = cbm_git_worktree_status(fixture, 4, &st);
git_env_hook_leave(&snap);
bool available = st.available;
int tracked = st.tracked_count;
int untracked = st.untracked_count;
cbm_git_worktree_status_free(&st);
th_rmtree(root);
ASSERT_EQ(rc, 0);
ASSERT_TRUE(available);
ASSERT_EQ(tracked, 0); /* the fixture is clean; the decoy is not */
ASSERT_EQ(untracked, 0);
PASS();
#endif /* _WIN32 */
}
/* ── Bounded worktree status (BT-240 increment 3) ──────────────────────
* These run on EVERY platform, not just POSIX: they shell out through
* cbm_popen instead of system(), so they work whenever git is on PATH —
* Windows CI included. The
* core status parser is platform-neutral and must be exercised everywhere git
* is available; only a genuinely missing git skips. */
static int status_git_run(const char *dir, const char *args) {
char cmd[1024];
#ifdef _WIN32
const char *null_dev = "NUL";
#else
const char *null_dev = "/dev/null";
#endif
snprintf(cmd, sizeof(cmd), "git -C \"%s\" %s 2>%s", dir, args, null_dev);
FILE *fp = cbm_popen(cmd, "r");
if (!fp) {
return -1;
}
char drain[256];
while (fgets(drain, sizeof(drain), fp)) {
}
return cbm_pclose(fp);
}
static int status_make_repo(const char *dir) {
if (th_mkdir_p(dir) != 0) return -1;
if (status_git_run(dir, "init -q") != 0) return -1;
if (status_git_run(dir, "config user.email test@example.com") != 0) return -1;
if (status_git_run(dir, "config user.name Test") != 0) return -1;
if (th_write_file(TH_PATH(dir, ".keep"), "") != 0) return -1;
if (status_git_run(dir, "add -A") != 0) return -1;
if (status_git_run(dir, "commit -qm init") != 0) return -1;
return 0;
}
TEST(worktree_status_clean) {
char *tmp = th_mktempdir("cbm_wtstatus");
if (!tmp) FAIL("th_mktempdir returned NULL");
if (status_make_repo(tmp) != 0) {
th_rmtree(tmp);
SKIP_PLATFORM("git not available to init a repo");
}
cbm_worktree_status_t st = {0};
int rc = cbm_git_worktree_status(tmp, 8, &st);
if (rc != 0 || !st.available) {
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
FAIL("clean repo status not available");
}
ASSERT_EQ(st.tracked_count, 0);
ASSERT_EQ(st.untracked_count, 0);
ASSERT_EQ(st.tracked_sample_count, 0);
ASSERT_EQ(st.untracked_sample_count, 0);
ASSERT_FALSE(st.tracked_truncated);
ASSERT_FALSE(st.untracked_truncated);
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
PASS();
}
TEST(worktree_status_tracked_modified) {
char *tmp = th_mktempdir("cbm_wtstatus");
if (!tmp) FAIL("th_mktempdir returned NULL");
if (status_make_repo(tmp) != 0) {
th_rmtree(tmp);
SKIP_PLATFORM("git not available to init a repo");
}
if (th_write_file(TH_PATH(tmp, "tracked.txt"), "v1") != 0 ||
status_git_run(tmp, "add -f -- tracked.txt") != 0 ||
status_git_run(tmp, "commit -q -m add-tracked") != 0) {
th_rmtree(tmp);
FAIL("failed to commit tracked file");
}
if (th_write_file(TH_PATH(tmp, "tracked.txt"), "v2") != 0) {
th_rmtree(tmp);
FAIL("failed to modify tracked file");
}
cbm_worktree_status_t st = {0};
int rc = cbm_git_worktree_status(tmp, 8, &st);
if (rc != 0 || !st.available) {
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
FAIL("status not available");
}
ASSERT_EQ(st.tracked_count, 1);
ASSERT_EQ(st.untracked_count, 0);
ASSERT_EQ(st.tracked_sample_count, 1);
ASSERT_STR_EQ(st.tracked_paths[0], "tracked.txt");
ASSERT_FALSE(st.tracked_truncated);
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
PASS();
}
TEST(worktree_status_untracked) {
char *tmp = th_mktempdir("cbm_wtstatus");
if (!tmp) FAIL("th_mktempdir returned NULL");
if (status_make_repo(tmp) != 0) {
th_rmtree(tmp);
SKIP_PLATFORM("git not available to init a repo");
}
if (th_write_file(TH_PATH(tmp, "newfile.txt"), "n") != 0) {
th_rmtree(tmp);
FAIL("failed to create untracked file");
}
cbm_worktree_status_t st = {0};
int rc = cbm_git_worktree_status(tmp, 8, &st);
if (rc != 0 || !st.available) {
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
FAIL("status not available");
}
ASSERT_EQ(st.untracked_count, 1);
ASSERT_EQ(st.tracked_count, 0);
ASSERT_EQ(st.untracked_sample_count, 1);
ASSERT_STR_EQ(st.untracked_paths[0], "newfile.txt");
ASSERT_FALSE(st.untracked_truncated);
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
PASS();
}
TEST(worktree_status_rename_counts_once) {
char *tmp = th_mktempdir("cbm_wtstatus");
if (!tmp) FAIL("th_mktempdir returned NULL");
if (status_make_repo(tmp) != 0) {
th_rmtree(tmp);
SKIP_PLATFORM("git not available to init a repo");
}
if (th_write_file(TH_PATH(tmp, "old.txt"), "o") != 0 ||
th_write_file(TH_PATH(tmp, "other.txt"), "x") != 0 ||
status_git_run(tmp, "add -A") != 0 ||
status_git_run(tmp, "commit -qm base") != 0 ||
status_git_run(tmp, "mv old.txt new.txt") != 0) {
th_rmtree(tmp);
FAIL("failed to stage a rename");
}
cbm_worktree_status_t st = {0};
int rc = cbm_git_worktree_status(tmp, 8, &st);
if (rc != 0 || !st.available) {
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
FAIL("status not available");
}
ASSERT_EQ(st.tracked_count, 1); /* rename/copy counts ONCE, not twice */
ASSERT_EQ(st.tracked_sample_count, 1);
ASSERT_STR_EQ(st.tracked_paths[0], "new.txt"); /* sampled NEW path */
ASSERT_EQ(st.untracked_count, 0);
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
PASS();
}
TEST(worktree_status_sample_cap_truncates) {
char *tmp = th_mktempdir("cbm_wtstatus");
if (!tmp) FAIL("th_mktempdir returned NULL");
if (status_make_repo(tmp) != 0) {
th_rmtree(tmp);
SKIP_PLATFORM("git not available to init a repo");
}
enum { N_FILES = 5, SAMPLE_MAX = 2 };
for (int i = 0; i < N_FILES; i++) {
char path[1024];
snprintf(path, sizeof(path), "%s/u%d.txt", tmp, i);
if (th_write_file(path, "u") != 0) {
th_rmtree(tmp);
FAIL("failed to create untracked file");
}
}
cbm_worktree_status_t st = {0};
int rc = cbm_git_worktree_status(tmp, SAMPLE_MAX, &st);
if (rc != 0 || !st.available) {
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
FAIL("status not available");
}
ASSERT_EQ(st.untracked_count, N_FILES); /* full stream counted... */
ASSERT_EQ(st.untracked_sample_count, SAMPLE_MAX); /* ...samples bounded */
ASSERT_TRUE(st.untracked_truncated);
ASSERT_EQ(st.tracked_count, 0);
ASSERT_FALSE(st.tracked_truncated);
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
PASS();
}
TEST(worktree_status_mixed_tracked_and_untracked) {
char *tmp = th_mktempdir("cbm_wtstatus");
if (!tmp) FAIL("th_mktempdir returned NULL");
if (status_make_repo(tmp) != 0) {
th_rmtree(tmp);
SKIP_PLATFORM("git not available to init a repo");
}
if (th_write_file(TH_PATH(tmp, "tracked.txt"), "v1") != 0 ||
status_git_run(tmp, "add -f -- tracked.txt") != 0 ||
status_git_run(tmp, "commit -q -m add-tracked") != 0) {
th_rmtree(tmp);
FAIL("failed to commit tracked file");
}
if (th_write_file(TH_PATH(tmp, "tracked.txt"), "v2") != 0 ||
th_write_file(TH_PATH(tmp, "untracked.txt"), "n") != 0) {
th_rmtree(tmp);
FAIL("failed to prepare mixed worktree");
}
cbm_worktree_status_t st = {0};
int rc = cbm_git_worktree_status(tmp, 8, &st);
if (rc != 0 || !st.available) {
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
FAIL("status not available");
}
ASSERT_EQ(st.tracked_count, 1);
ASSERT_EQ(st.untracked_count, 1);
ASSERT_STR_EQ(st.tracked_paths[0], "tracked.txt");
ASSERT_STR_EQ(st.untracked_paths[0], "untracked.txt");
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
PASS();
}
/* Fail-closed contract: a non-repo directory must report unavailable with
* zero counts — never a silent "clean" tree. Does not need git on PATH. */
TEST(worktree_status_unavailable_non_repo) {
char *tmp = th_mktempdir("cbm_wtstatus");
if (!tmp) FAIL("th_mktempdir returned NULL");
cbm_worktree_status_t st = {0};
int rc = cbm_git_worktree_status(tmp, 8, &st);
if (rc != 0) {
th_rmtree(tmp);
FAIL("status call returned an error");
}
ASSERT_FALSE(st.available);
ASSERT_EQ(st.tracked_count, 0);
ASSERT_EQ(st.untracked_count, 0);
ASSERT_EQ(st.tracked_sample_count, 0);
ASSERT_EQ(st.untracked_sample_count, 0);
cbm_git_worktree_status_free(&st);
th_rmtree(tmp);
PASS();
}
/* ── Suite ──────────────────────────────────────────────────────── */
SUITE(git_context) {
@@ -503,6 +962,16 @@ SUITE(git_context) {
RUN_TEST(canonical_root_repo_root);
RUN_TEST(canonical_root_subdir);
RUN_TEST(canonical_root_linked_worktree);
RUN_TEST(is_linked_worktree_true_for_linked_worktree);
RUN_TEST(is_linked_worktree_false_for_submodule_and_nongit);
RUN_TEST(git_context_ignores_inherited_repo_env);
RUN_TEST(githistory_ignores_inherited_repo_env);
RUN_TEST(worktree_status_ignores_inherited_repo_env);
RUN_TEST(worktree_status_clean);
RUN_TEST(worktree_status_tracked_modified);
RUN_TEST(worktree_status_untracked);
RUN_TEST(worktree_status_rename_counts_once);
RUN_TEST(worktree_status_sample_cap_truncates);
RUN_TEST(worktree_status_mixed_tracked_and_untracked);
RUN_TEST(worktree_status_unavailable_non_repo);
}
tests/test_install_android_guard.sh
Executable
+51
View File
@@ -0,0 +1,51 @@
#!/usr/bin/env bash
set -euo pipefail
ROOT=$(cd "$(dirname "${BASH_SOURCE[0]}")/.." && pwd)
WORK=$(mktemp -d)
trap 'rm -rf "$WORK"' EXIT
mkdir -p "$WORK/bin" "$WORK/home"
cat >"$WORK/bin/uname" <<'EOF'
#!/usr/bin/env bash
case "$1" in
-s) printf '%s\n' Linux ;;
-m) printf '%s\n' aarch64 ;;
-o) printf '%s\n' Android ;;
*) exit 1 ;;
esac
EOF
cat >"$WORK/bin/curl" <<'EOF'
#!/usr/bin/env bash
printf 'curl must not run for Android/Termux\n' >&2
exit 99
EOF
chmod +x "$WORK/bin/uname" "$WORK/bin/curl"
# The stubs must be what install.sh sees, or this test proves nothing.
if [ "$(PATH="$WORK/bin:$PATH" uname -o)" != "Android" ]; then
printf 'FAIL: the uname stub is not picked up from PATH\n' >&2
exit 1
fi
set +e
output=$(PATH="$WORK/bin:$PATH" HOME="$WORK/home" \
CBM_DOWNLOAD_URL="http://127.0.0.1:9/cbm-android-guard-test" \
bash "$ROOT/install.sh" --skip-config 2>&1)
rc=$?
set -e
if [ "$rc" -eq 0 ]; then
printf 'FAIL: installer accepted Android/Termux\n' >&2
exit 1
fi
if ! grep -Fq 'Android/Termux' <<<"$output"; then
printf 'FAIL: missing Android/Termux guidance\n%s\n' "$output" >&2
exit 1
fi
if grep -Fq 'curl must not run' <<<"$output"; then
printf 'FAIL: installer downloaded before rejecting Android/Termux\n' >&2
exit 1
fi
printf 'PASS: Android/Termux is rejected before download\n'
tests/test_lsp_resolution_probe.c
+49 -2
View File
@@ -1837,16 +1837,62 @@ TEST(lrp_tsx_usage_import_type_with_decoy) {
PASS();
}
/* Python: constructor syntax is an exact call to the materialized Class node. */
/* Python: ClassName() with a user __init__ is an exact CALLS edge to that
* method. The Class node no longer receives the instantiation edge. */
TEST(lrp_python_usage_instantiation) {
static const LRP_File f[] = {
{"model.py", "class User:\n def __init__(self, name):\n self.name = name\n"},
{"main.py", "from .model import User\n\n\ndef create(name):\n return User(name)\n"}};
LRP_Proj lp;
cbm_store_t *store = lrp_index(&lp, f, 2);
int exact = store ? lrp_exact_calls_by_name(store, lp.project, "create", "User") : -1;
int exact = store ? lrp_exact_calls_by_name(store, lp.project, "create", "__init__") : -1;
int class_edge = store ? lrp_exact_calls_by_name(store, lp.project, "create", "User") : -1;
lrp_cleanup(&lp, store);
ASSERT_EQ(exact, 1);
ASSERT_EQ(class_edge, 0);
PASS();
}
/* Python same-file subclasses in the graph: ClassName() binds only to an
* __init__ the class declares itself. B(A) declares none, so make_b keeps
* its CALLS edge on the class B and the inherited A.__init__ gets none.
* C(A) declares its own __init__, so make_c calls C.__init__, not C and not
* the inherited A.__init__. */
TEST(lrp_python_subclass_constructor_own_init_only) {
static const LRP_File f[] = {{"main.py", "class A:\n"
" def __init__(self):\n"
" self.ready = True\n"
"\n"
"class B(A):\n"
" def go(self):\n"
" return 1\n"
"\n"
"class C(A):\n"
" def __init__(self):\n"
" self.ready = False\n"
"\n"
"def make_b():\n"
" return B()\n"
"\n"
"def make_c():\n"
" return C()\n"}};
LRP_Proj lp;
cbm_store_t *store = lrp_index(&lp, f, 1);
const char *p = store ? lp.project : NULL;
int b_class = lrp_exact_edge_by_qn_suffix(store, p, "CALLS", "main.make_b", "main.B");
int b_base_init =
lrp_exact_edge_by_qn_suffix(store, p, "CALLS", "main.make_b", "main.A.__init__");
int c_own_init =
lrp_exact_edge_by_qn_suffix(store, p, "CALLS", "main.make_c", "main.C.__init__");
int c_class = lrp_exact_edge_by_qn_suffix(store, p, "CALLS", "main.make_c", "main.C");
int c_base_init =
lrp_exact_edge_by_qn_suffix(store, p, "CALLS", "main.make_c", "main.A.__init__");
lrp_cleanup(&lp, store);
ASSERT_EQ(b_class, 1);
ASSERT_EQ(b_base_init, 0);
ASSERT_EQ(c_own_init, 1);
ASSERT_EQ(c_class, 0);
ASSERT_EQ(c_base_init, 0);
PASS();
}
@@ -1967,4 +2013,5 @@ SUITE(lsp_resolution_probe) {
RUN_TEST(lrp_ts_usage_import_type_with_decoy);
RUN_TEST(lrp_tsx_usage_import_type_with_decoy);
RUN_TEST(lrp_python_usage_instantiation);
RUN_TEST(lrp_python_subclass_constructor_own_init_only);
}
tests/test_main.c
+2
View File
@@ -1802,6 +1802,7 @@ extern void suite_php_lsp(void);
extern void suite_cs_lsp(void);
extern void suite_cs_lsp_bench(void);
extern void suite_perl_lsp(void);
extern void suite_ruby_lsp(void);
extern void suite_scope(void);
extern void suite_type_rep(void);
extern void suite_py_lsp(void);
@@ -2435,6 +2436,7 @@ int main(int argc, char **argv) {
RUN_SELECTED_SUITE(cs_lsp);
RUN_SELECTED_SUITE_PERF(cs_lsp_bench);
RUN_SELECTED_SUITE(perl_lsp);
RUN_SELECTED_SUITE(ruby_lsp);
RUN_SELECTED_SUITE(py_lsp);
RUN_SELECTED_SUITE(kotlin_lsp);
RUN_SELECTED_SUITE(kotlin_typed_calls);
tests/test_mcp.c
+813 -3
View File
@@ -18,6 +18,7 @@
#include "test_framework.h"
#include "test_helpers.h"
#include <cli/cli.h>
#include <git/git_context.h>
#include <mcp/index_supervisor.h> /* spawn-count hook — #845 in-process guard */
#include <mcp/mcp.h>
#include <mcp/mcp_internal.h>
@@ -1214,6 +1215,57 @@ TEST(mcp_initialize_response) {
PASS();
}
/* The lifecycle hook reads ignore_worktrees through this reader. It must never
* attach a store to the server (the daemon lends its session server) and never
* create the runtime store; a server with its own store answers from it. */
TEST(mcp_ignore_worktrees_runtime_read_leaves_server_and_store_alone) {
char *raw = th_mktempdir("cbm_mcp_runtime_config");
ASSERT_NOT_NULL(raw);
char cache[256];
snprintf(cache, sizeof(cache), "%s", raw);
char own_dir[320];
snprintf(own_dir, sizeof(own_dir), "%s/own", cache);
char store_path[400];
snprintf(store_path, sizeof(store_path), "%s/" CBM_CONFIG_DB_FILENAME, cache);
const char *saved = getenv("CBM_CACHE_DIR");
char *saved_copy = saved ? strdup(saved) : NULL;
cbm_setenv("CBM_CACHE_DIR", cache, 1);
cbm_mcp_server_t *server = cbm_mcp_server_new(NULL);
struct stat st;
bool absent_off = server && !cbm_mcp_ignore_worktrees_runtime_enabled(server);
bool still_absent = stat(store_path, &st) != 0;
cbm_config_t *runtime = cbm_config_open(cache);
bool stored = runtime && cbm_config_set(runtime, CBM_CONFIG_IGNORE_WORKTREES, "true") == 0;
cbm_config_close(runtime);
bool runtime_on = server && cbm_mcp_ignore_worktrees_runtime_enabled(server);
bool server_untouched = server && !cbm_mcp_ignore_worktrees_enabled(server);
cbm_config_t *own = cbm_config_open(own_dir);
if (server && own) {
cbm_mcp_server_set_config(server, own);
}
bool own_store_wins = server && own && !cbm_mcp_ignore_worktrees_runtime_enabled(server);
if (server) {
cbm_mcp_server_set_config(server, NULL);
}
cbm_mcp_server_free(server);
cbm_config_close(own);
restore_cache_dir(saved_copy);
free(saved_copy);
int removed = th_rmtree(cache);
ASSERT(absent_off);
ASSERT(still_absent);
ASSERT(stored);
ASSERT(runtime_on);
ASSERT(server_untouched);
ASSERT(own_store_wins);
ASSERT_EQ(removed, 0);
PASS();
}
TEST(mcp_tools_list) {
char *json = cbm_mcp_tools_list();
ASSERT_NOT_NULL(json);
@@ -7839,9 +7891,465 @@ TEST(tool_index_status_includes_git_metadata) {
PASS();
}
/* ══════════════════════════════════════════════════════════════════
* TOOL HANDLERS WITH DATA
* ══════════════════════════════════════════════════════════════════ */
/* BT-240 RED: a live checkout SHA is not proof of the generation that produced
* graph content. Older databases lack an indexed-checkout identity, so verbose
* status must fail closed as unknown while exposing graph generation
* separately. */
TEST(tool_index_status_fails_closed_without_indexed_checkout_identity) {
char tmp[256];
cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
ASSERT_NOT_NULL(srv);
char *resp = cbm_mcp_handle_tool(
srv, "index_status",
"{\"project\":\"test-project\",\"verbose\":true,\"format\":\"json\"}");
ASSERT_NOT_NULL(resp);
char *inner = extract_text_content(resp);
ASSERT_NOT_NULL(inner);
ASSERT_NOT_NULL(strstr(inner, "\"freshness\""));
ASSERT_NOT_NULL(strstr(inner, "\"verdict\":\"unknown\""));
ASSERT_NOT_NULL(strstr(inner, "\"indexed_generation\""));
ASSERT_NOT_NULL(strstr(inner, "\"indexed_checkout_sha\":null"));
ASSERT_NOT_NULL(strstr(inner, "indexed_checkout_unavailable"));
free(inner);
free(resp);
cbm_mcp_server_free(srv);
cleanup_snippet_dir(tmp);
PASS();
}
/* BT-240 lean-default guard: the freshness verdict is diagnostics — a
* report-only signal that never auto-indexes — so it must stay out of the
* common (non-verbose) status call. */
TEST(tool_index_status_omits_freshness_by_default) {
char tmp[256];
cbm_mcp_server_t *srv = setup_snippet_server(tmp, sizeof(tmp));
ASSERT_NOT_NULL(srv);
char *resp = cbm_mcp_handle_tool(
srv, "index_status", "{\"project\":\"test-project\",\"format\":\"json\"}");
ASSERT_NOT_NULL(resp);
char *inner = extract_text_content(resp);
ASSERT_NOT_NULL(inner);
ASSERT_NOT_NULL(strstr(inner, "\"status\""));
ASSERT_NULL(strstr(inner, "\"freshness\""));
ASSERT_NULL(strstr(inner, "indexed_checkout_sha"));
/* BT-240 increment 3: the worktree-status snapshot is part of the
* verbose-only freshness block and must not leak into the default call. */
ASSERT_NULL(strstr(inner, "status_available"));
ASSERT_NULL(strstr(inner, "tracked_changes"));
ASSERT_NULL(strstr(inner, "untracked_source"));
free(inner);
free(resp);
cbm_mcp_server_free(srv);
cleanup_snippet_dir(tmp);
PASS();
}
/* ── BT-240: freshness verdict against the recorded indexed checkout ──
* These shell out to git via cbm_popen (the same isolated spawn production
* git_context uses) rather than system(), so they run on every platform that
* has git on PATH — Windows CI included. A genuinely missing git is the only
* skip. */
static int mcp_git_run(const char *dir, const char *args) {
char cmd[1024];
#ifdef _WIN32
const char *null_dev = "NUL";
#else
const char *null_dev = "/dev/null";
#endif
snprintf(cmd, sizeof(cmd), "git -C \"%s\" %s 2>%s", dir, args, null_dev);
FILE *fp = cbm_popen(cmd, "r");
if (!fp) {
return -1;
}
char drain[256];
while (fgets(drain, sizeof(drain), fp)) {
}
return cbm_pclose(fp);
}
static int mcp_make_git_repo(const char *dir) {
if (th_mkdir_p(dir) != 0) return -1;
if (mcp_git_run(dir, "init -q") != 0) return -1;
if (mcp_git_run(dir, "config user.email test@example.com") != 0) return -1;
if (mcp_git_run(dir, "config user.name Test") != 0) return -1;
if (th_write_file(TH_PATH(dir, ".keep"), "") != 0) return -1;
if (mcp_git_run(dir, "add -A") != 0) return -1;
if (mcp_git_run(dir, "commit -qm init") != 0) return -1;
return 0;
}
/* Helper: build a server whose project root is the given git repo and whose
* coverage metadata records indexed_checkout_sha = sha (may be NULL). */
static cbm_mcp_server_t *mcp_freshness_server(const char *repo, const char *sha) {
cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
if (!srv) return NULL;
cbm_store_t *st = cbm_mcp_server_store(srv);
if (!st) {
cbm_mcp_server_free(srv);
return NULL;
}
cbm_mcp_server_set_project(srv, "fresh-project");
cbm_store_upsert_project(st, "fresh-project", repo);
cbm_coverage_meta_t meta = {
.generation = "fresh-generation",
.index_mode = "fast",
.recorded_at = "2026-08-11T00:00:00Z",
.recording_status = "complete",
.coverage_version = 1,
.hash_records_complete = true,
.indexed_checkout_sha = sha,
};
if (cbm_store_coverage_replace_ex(st, "fresh-project", NULL, 0, &meta) != CBM_STORE_OK) {
cbm_mcp_server_free(srv);
return NULL;
}
return srv;
}
TEST(tool_index_status_freshness_verdict_current_when_indexed_checkout_matches) {
char *repo = th_mktempdir("cbm_fresh_git");
if (!repo) FAIL("th_mktempdir returned NULL");
if (mcp_make_git_repo(repo) != 0) {
th_rmtree(repo);
SKIP_PLATFORM("git not available to init a repo");
}
cbm_git_context_t ctx = {0};
if (cbm_git_context_resolve(repo, &ctx) != 0 || !ctx.head_sha || !ctx.head_sha[0]) {
cbm_git_context_free(&ctx);
th_rmtree(repo);
SKIP_PLATFORM("git head not resolvable");
}
char *head = strdup(ctx.head_sha);
cbm_git_context_free(&ctx);
cbm_mcp_server_t *srv = mcp_freshness_server(repo, head);
if (!srv) {
free(head);
th_rmtree(repo);
FAIL("mcp_freshness_server failed");
}
char *resp = cbm_mcp_handle_tool(
srv, "index_status",
"{\"project\":\"fresh-project\",\"verbose\":true,\"format\":\"json\"}");
ASSERT_NOT_NULL(resp);
char *inner = extract_text_content(resp);
ASSERT_NOT_NULL(inner);
ASSERT_NOT_NULL(strstr(inner, "\"verdict\":\"current\""));
ASSERT_NOT_NULL(strstr(inner, "indexed_checkout_current"));
ASSERT_NOT_NULL(strstr(inner, "\"indexed_checkout_sha\":\""));
ASSERT_NOT_NULL(strstr(inner, "\"checkout_sha\":\""));
ASSERT_NOT_NULL(strstr(inner, "\"recommended_action\":\"use_graph\""));
ASSERT_NOT_NULL(strstr(inner, "\"status_available\":true"));
ASSERT_NOT_NULL(strstr(inner, "\"tracked_changes\":"));
ASSERT_NOT_NULL(strstr(inner, "\"untracked_source\":"));
ASSERT_NOT_NULL(strstr(inner, "\"count\":0"));
free(inner);
free(resp);
cbm_mcp_server_free(srv);
free(head);
th_rmtree(repo);
PASS();
}
TEST(tool_index_status_freshness_verdict_stale_when_indexed_checkout_mismatches) {
char *repo = th_mktempdir("cbm_fresh_git");
if (!repo) FAIL("th_mktempdir returned NULL");
if (mcp_make_git_repo(repo) != 0) {
th_rmtree(repo);
SKIP_PLATFORM("git not available to init a repo");
}
/* A stale recorded identity that does not equal the live HEAD. */
cbm_mcp_server_t *srv = mcp_freshness_server(repo, "0000000000000000000000000000000000000000");
if (!srv) {
th_rmtree(repo);
FAIL("mcp_freshness_server failed");
}
char *resp = cbm_mcp_handle_tool(
srv, "index_status",
"{\"project\":\"fresh-project\",\"verbose\":true,\"format\":\"json\"}");
ASSERT_NOT_NULL(resp);
char *inner = extract_text_content(resp);
ASSERT_NOT_NULL(inner);
ASSERT_NOT_NULL(strstr(inner, "\"verdict\":\"stale\""));
ASSERT_NOT_NULL(strstr(inner, "indexed_checkout_mismatch"));
ASSERT_NOT_NULL(strstr(inner, "\"indexed_checkout_sha\":\"0000000000000000000000000000000000000000\""));
ASSERT_NOT_NULL(strstr(inner, "\"checkout_sha\":\""));
ASSERT_NOT_NULL(strstr(inner, "\"recommended_action\":\"reindex_to_match_checkout\""));
free(inner);
free(resp);
cbm_mcp_server_free(srv);
th_rmtree(repo);
PASS();
}
/* BT-240 increment 3: a modified tracked file makes the verdict stale even
* when the indexed SHA matches the live HEAD, with the sample surfaced. */
TEST(tool_index_status_freshness_verdict_stale_when_tracked_changes) {
char *repo = th_mktempdir("cbm_fresh_git");
if (!repo) FAIL("th_mktempdir returned NULL");
if (mcp_make_git_repo(repo) != 0) {
th_rmtree(repo);
SKIP_PLATFORM("git not available to init a repo");
}
if (th_write_file(TH_PATH(repo, "tracked.txt"), "v1") != 0 ||
mcp_git_run(repo, "add -f -- tracked.txt") != 0 ||
mcp_git_run(repo, "commit -q -m add-tracked") != 0) {
th_rmtree(repo);
FAIL("failed to commit tracked file");
}
cbm_git_context_t ctx = {0};
if (cbm_git_context_resolve(repo, &ctx) != 0 || !ctx.head_sha || !ctx.head_sha[0]) {
cbm_git_context_free(&ctx);
th_rmtree(repo);
SKIP_PLATFORM("git head not resolvable");
}
char *head = strdup(ctx.head_sha);
cbm_git_context_free(&ctx);
if (th_write_file(TH_PATH(repo, "tracked.txt"), "v2") != 0) {
free(head);
th_rmtree(repo);
FAIL("failed to modify tracked file");
}
cbm_mcp_server_t *srv = mcp_freshness_server(repo, head);
if (!srv) {
free(head);
th_rmtree(repo);
FAIL("mcp_freshness_server failed");
}
char *resp = cbm_mcp_handle_tool(
srv, "index_status",
"{\"project\":\"fresh-project\",\"verbose\":true,\"format\":\"json\"}");
ASSERT_NOT_NULL(resp);
char *inner = extract_text_content(resp);
ASSERT_NOT_NULL(inner);
ASSERT_NOT_NULL(strstr(inner, "\"verdict\":\"stale\""));
ASSERT_NOT_NULL(strstr(inner, "tracked_changes_present"));
ASSERT_NOT_NULL(strstr(inner, "\"tracked_changes\":"));
ASSERT_NOT_NULL(strstr(inner, "\"count\":1"));
ASSERT_NOT_NULL(strstr(inner, "\"paths\":[\"tracked.txt\"]"));
ASSERT_NOT_NULL(strstr(inner, "\"truncated\":false"));
ASSERT_NULL(strstr(inner, "indexed_checkout_current"));
free(inner);
free(resp);
cbm_mcp_server_free(srv);
free(head);
th_rmtree(repo);
PASS();
}
/* BT-240 increment 3: untracked sources prevent "current" — verdict is
* unknown (no stale reason), with the untracked_not_indexed reason. */
TEST(tool_index_status_freshness_verdict_unknown_when_untracked_only) {
char *repo = th_mktempdir("cbm_fresh_git");
if (!repo) FAIL("th_mktempdir returned NULL");
if (mcp_make_git_repo(repo) != 0) {
th_rmtree(repo);
SKIP_PLATFORM("git not available to init a repo");
}
if (th_write_file(TH_PATH(repo, "newfile.txt"), "n") != 0) {
th_rmtree(repo);
FAIL("failed to create untracked file");
}
cbm_git_context_t ctx = {0};
if (cbm_git_context_resolve(repo, &ctx) != 0 || !ctx.head_sha || !ctx.head_sha[0]) {
cbm_git_context_free(&ctx);
th_rmtree(repo);
SKIP_PLATFORM("git head not resolvable");
}
char *head = strdup(ctx.head_sha);
cbm_git_context_free(&ctx);
cbm_mcp_server_t *srv = mcp_freshness_server(repo, head);
if (!srv) {
free(head);
th_rmtree(repo);
FAIL("mcp_freshness_server failed");
}
char *resp = cbm_mcp_handle_tool(
srv, "index_status",
"{\"project\":\"fresh-project\",\"verbose\":true,\"format\":\"json\"}");
ASSERT_NOT_NULL(resp);
char *inner = extract_text_content(resp);
ASSERT_NOT_NULL(inner);
ASSERT_NOT_NULL(strstr(inner, "\"verdict\":\"unknown\""));
ASSERT_NOT_NULL(strstr(inner, "untracked_not_indexed"));
ASSERT_NOT_NULL(strstr(inner, "\"untracked_source\":"));
ASSERT_NOT_NULL(strstr(inner, "\"count\":1"));
ASSERT_NULL(strstr(inner, "indexed_checkout_current"));
free(inner);
free(resp);
cbm_mcp_server_free(srv);
free(head);
th_rmtree(repo);
PASS();
}
/* BT-240 increment 3: tracked changes win over untracked — both reasons are
* present but the verdict is stale, never unknown. */
TEST(tool_index_status_freshness_verdict_stale_when_tracked_and_untracked) {
char *repo = th_mktempdir("cbm_fresh_git");
if (!repo) FAIL("th_mktempdir returned NULL");
if (mcp_make_git_repo(repo) != 0) {
th_rmtree(repo);
SKIP_PLATFORM("git not available to init a repo");
}
if (th_write_file(TH_PATH(repo, "tracked.txt"), "v1") != 0 ||
mcp_git_run(repo, "add -f -- tracked.txt") != 0 ||
mcp_git_run(repo, "commit -q -m add-tracked") != 0) {
th_rmtree(repo);
FAIL("failed to commit tracked file");
}
cbm_git_context_t ctx = {0};
if (cbm_git_context_resolve(repo, &ctx) != 0 || !ctx.head_sha || !ctx.head_sha[0]) {
cbm_git_context_free(&ctx);
th_rmtree(repo);
SKIP_PLATFORM("git head not resolvable");
}
char *head = strdup(ctx.head_sha);
cbm_git_context_free(&ctx);
if (th_write_file(TH_PATH(repo, "tracked.txt"), "v2") != 0 ||
th_write_file(TH_PATH(repo, "untracked.txt"), "n") != 0) {
free(head);
th_rmtree(repo);
FAIL("failed to prepare mixed worktree");
}
cbm_mcp_server_t *srv = mcp_freshness_server(repo, head);
if (!srv) {
free(head);
th_rmtree(repo);
FAIL("mcp_freshness_server failed");
}
char *resp = cbm_mcp_handle_tool(
srv, "index_status",
"{\"project\":\"fresh-project\",\"verbose\":true,\"format\":\"json\"}");
ASSERT_NOT_NULL(resp);
char *inner = extract_text_content(resp);
ASSERT_NOT_NULL(inner);
ASSERT_NOT_NULL(strstr(inner, "\"verdict\":\"stale\""));
ASSERT_NOT_NULL(strstr(inner, "tracked_changes_present"));
ASSERT_NOT_NULL(strstr(inner, "untracked_not_indexed"));
free(inner);
free(resp);
cbm_mcp_server_free(srv);
free(head);
th_rmtree(repo);
PASS();
}
/* BT-240 increment 3: a non-git root with a recorded identity cannot prove
* current — status availability must be false and the verdict unknown. */
TEST(tool_index_status_freshness_status_unavailable_non_git) {
char *repo = th_mktempdir("cbm_fresh_non_git");
if (!repo) FAIL("th_mktempdir returned NULL");
/* Record an identity even though the root is not a git repository. */
cbm_mcp_server_t *srv = mcp_freshness_server(repo, "0123456789012345678901234567890123456789");
if (!srv) {
th_rmtree(repo);
FAIL("mcp_freshness_server failed");
}
char *resp = cbm_mcp_handle_tool(
srv, "index_status",
"{\"project\":\"fresh-project\",\"verbose\":true,\"format\":\"json\"}");
ASSERT_NOT_NULL(resp);
char *inner = extract_text_content(resp);
ASSERT_NOT_NULL(inner);
ASSERT_NOT_NULL(strstr(inner, "\"status_available\":false"));
ASSERT_NOT_NULL(strstr(inner, "status_unavailable"));
ASSERT_NOT_NULL(strstr(inner, "\"verdict\":\"unknown\""));
ASSERT_NULL(strstr(inner, "indexed_checkout_current"));
ASSERT_NOT_NULL(strstr(inner, "\"tracked_changes\":"));
ASSERT_NOT_NULL(strstr(inner, "\"untracked_source\":"));
ASSERT_NOT_NULL(strstr(inner, "\"count\":0"));
free(inner);
free(resp);
cbm_mcp_server_free(srv);
th_rmtree(repo);
PASS();
}
/* BT-240 increment 3: sample cap at the MCP layer — many untracked sources
* surface the true count, a bounded paths array and truncated=true. */
TEST(tool_index_status_freshness_sample_cap_truncates) {
char *repo = th_mktempdir("cbm_fresh_git");
if (!repo) FAIL("th_mktempdir returned NULL");
if (mcp_make_git_repo(repo) != 0) {
th_rmtree(repo);
SKIP_PLATFORM("git not available to init a repo");
}
enum { N_FILES = 17, MCP_SAMPLE_MAX = 16 };
for (int i = 0; i < N_FILES; i++) {
char path[1024];
snprintf(path, sizeof(path), "%s/u%02d.txt", repo, i);
if (th_write_file(path, "u") != 0) {
th_rmtree(repo);
FAIL("failed to create untracked file");
}
}
cbm_git_context_t ctx = {0};
if (cbm_git_context_resolve(repo, &ctx) != 0 || !ctx.head_sha || !ctx.head_sha[0]) {
cbm_git_context_free(&ctx);
th_rmtree(repo);
SKIP_PLATFORM("git head not resolvable");
}
char *head = strdup(ctx.head_sha);
cbm_git_context_free(&ctx);
cbm_mcp_server_t *srv = mcp_freshness_server(repo, head);
if (!srv) {
free(head);
th_rmtree(repo);
FAIL("mcp_freshness_server failed");
}
char *resp = cbm_mcp_handle_tool(
srv, "index_status",
"{\"project\":\"fresh-project\",\"verbose\":true,\"format\":\"json\"}");
ASSERT_NOT_NULL(resp);
char *inner = extract_text_content(resp);
ASSERT_NOT_NULL(inner);
ASSERT_NOT_NULL(strstr(inner, "\"untracked_source\":"));
ASSERT_NOT_NULL(strstr(inner, "\"count\":17"));
ASSERT_NOT_NULL(strstr(inner, "\"truncated\":true"));
static const char EXPECTED_PATHS[] =
"\"paths\":[\"u00.txt\",\"u01.txt\",\"u02.txt\",\"u03.txt\",\"u04.txt\",\"u05.txt\","
"\"u06.txt\",\"u07.txt\",\"u08.txt\",\"u09.txt\",\"u10.txt\",\"u11.txt\",\"u12.txt\","
"\"u13.txt\",\"u14.txt\",\"u15.txt\"]";
ASSERT_NOT_NULL(strstr(inner, EXPECTED_PATHS));
free(inner);
free(resp);
cbm_mcp_server_free(srv);
free(head);
th_rmtree(repo);
PASS();
}
/* #2816: stored recursion must remain visible even when the CALLS graph has
* no self-edges. Removing metadata emission must fail these assertions. */
@@ -24438,6 +24946,291 @@ TEST(mcp_auto_watch_false_skips_watcher_on_connect) {
PASS();
}
/* ═══════════════════════════════════════════════════════════════
* ignore_worktrees — explicit index_repository on a linked worktree
* ═══════════════════════════════════════════════════════════════ */
/* An EXPLICIT index_repository call is refused only when ignore_worktrees is on
* AND repo_path is a linked worktree AND no per-call override was passed. The
* refusal must never fire for the MAIN checkout — that would break ordinary
* indexing for anyone enabling the key — and index_worktree=true must escape it.
*
* Default-off is the regression class the project guards hardest: with the key
* unset, a linked worktree still indexes exactly as today.
*
* Probe returns a bit set, or a negative fixture-setup code. */
enum {
IGNORE_WT_REFUSED_WORKTREE = 1, /* expected when the key is on */
IGNORE_WT_REFUSED_MAIN = 2, /* BUG if set */
IGNORE_WT_REFUSED_OVERRIDE = 4, /* BUG if set */
};
#ifndef _WIN32
typedef struct {
char cache[256];
char main_repo[512];
char wt_repo[512];
} ignore_wt_fixture_t;
static void ignore_wt_fixture_cleanup(ignore_wt_fixture_t *fx) {
if (!fx) {
return;
}
if (fx->main_repo[0]) {
char prune[1024];
snprintf(prune, sizeof(prune), "git -C \"%s\" worktree prune >/dev/null 2>&1", fx->main_repo);
(void)system(prune);
}
if (fx->cache[0]) {
th_rmtree(fx->cache);
}
}
/* 0 = ready. -1 tmpdir, -2 mkdir, -3 git worktree fixture unavailable. */
static int ignore_wt_fixture_setup(ignore_wt_fixture_t *fx) {
memset(fx, 0, sizeof(*fx));
char *raw = th_mktempdir("cbm_ignorewt");
if (!raw) {
return -1;
}
snprintf(fx->cache, sizeof(fx->cache), "%s", raw);
snprintf(fx->main_repo, sizeof(fx->main_repo), "%s/main", fx->cache);
snprintf(fx->wt_repo, sizeof(fx->wt_repo), "%s/wt", fx->cache);
if (th_mkdir_p(fx->main_repo) != 0) {
ignore_wt_fixture_cleanup(fx);
return -2;
}
char cmd[2048];
snprintf(cmd, sizeof(cmd),
"git -C \"%s\" init -q >/dev/null 2>&1 && "
"git -C \"%s\" config user.email t@example.com && "
"git -C \"%s\" config user.name T && touch \"%s/.keep\" && "
"git -C \"%s\" add .keep && git -C \"%s\" commit -q -m init && "
"git -C \"%s\" worktree add -q \"%s\" -b wtb",
fx->main_repo, fx->main_repo, fx->main_repo, fx->main_repo, fx->main_repo,
fx->main_repo, fx->main_repo, fx->wt_repo);
if (system(cmd) != 0) {
ignore_wt_fixture_cleanup(fx);
return -3;
}
return 0;
}
static bool ignore_wt_refused(cbm_mcp_server_t *srv, const char *repo_path, bool override) {
char args[2048];
snprintf(args, sizeof(args), "{\"repo_path\":\"%s\"%s}", repo_path,
override ? ",\"index_worktree\":true" : "");
char *result = cbm_mcp_handle_tool(srv, "index_repository", args);
bool refused = result && strstr(result, "ignore_worktrees is enabled") != NULL;
free(result);
return refused;
}
static int ignore_worktrees_index_probe(const char *ignore_value) {
ignore_wt_fixture_t fx;
int setup = ignore_wt_fixture_setup(&fx);
if (setup < 0) {
return setup;
}
const char *saved = getenv("CBM_CACHE_DIR");
char *saved_copy = saved ? strdup(saved) : NULL;
cbm_setenv("CBM_CACHE_DIR", fx.cache, 1);
int bits = -4;
cbm_config_t *cfg = cbm_config_open(fx.cache);
if (cfg) {
if (ignore_value) {
cbm_config_set(cfg, CBM_CONFIG_IGNORE_WORKTREES, ignore_value);
}
cbm_mcp_server_t *srv = cbm_mcp_server_new(NULL);
if (srv) {
cbm_mcp_server_set_config(srv, cfg);
bits = 0;
if (ignore_wt_refused(srv, fx.wt_repo, false)) {
bits |= IGNORE_WT_REFUSED_WORKTREE;
}
if (ignore_wt_refused(srv, fx.main_repo, false)) {
bits |= IGNORE_WT_REFUSED_MAIN;
}
if (ignore_wt_refused(srv, fx.wt_repo, true)) {
bits |= IGNORE_WT_REFUSED_OVERRIDE;
}
cbm_mcp_server_free(srv);
}
cbm_config_close(cfg);
}
restore_cache_dir(saved_copy);
free(saved_copy);
ignore_wt_fixture_cleanup(&fx);
return bits;
}
#ifdef CBM_ENABLE_TEST_SEAMS
static void ignore_wt_count_started(void *context) {
int *calls = context;
(*calls)++;
}
/* Drive initialize → maybe_auto_index on a linked worktree. ignore_value NULL
* leaves the key unset (default-off). The count hook fires only if auto-index
* reaches discovery, so a skip for linked_worktree must leave it at 0. */
static int ignore_wt_autoindex_count_calls(const char *session_root, const char *ignore_value) {
char *raw = th_mktempdir("cbm_ignorewt_auto");
if (!raw) {
return -1;
}
char cache[256];
snprintf(cache, sizeof(cache), "%s", raw);
const char *saved = getenv("CBM_CACHE_DIR");
char *saved_copy = saved ? strdup(saved) : NULL;
cbm_setenv("CBM_CACHE_DIR", cache, 1);
char old_cwd[1024];
if (!cbm_getcwd(old_cwd, sizeof(old_cwd)) || cbm_chdir(session_root) != 0) {
restore_cache_dir(saved_copy);
free(saved_copy);
th_cleanup(cache);
return -2;
}
int calls = -3;
cbm_config_t *cfg = cbm_config_open(cache);
cbm_mcp_server_t *srv = cfg ? cbm_mcp_server_new(NULL) : NULL;
if (srv) {
cbm_config_set(cfg, CBM_CONFIG_AUTO_INDEX, "true");
/* Fail-closed on the actual count so this never launches an index thread. */
cbm_config_set(cfg, CBM_CONFIG_AUTO_INDEX_LIMIT, "-1");
if (ignore_value) {
cbm_config_set(cfg, CBM_CONFIG_IGNORE_WORKTREES, ignore_value);
}
cbm_mcp_server_set_config(srv, cfg);
calls = 0;
cbm_mcp_server_set_auto_index_count_test_hook(srv, ignore_wt_count_started, &calls);
char *response = cbm_mcp_server_handle(
srv, "{\"jsonrpc\":\"2.0\",\"id\":1430,\"method\":\"initialize\",\"params\":{}}");
free(response);
cbm_mcp_server_free(srv);
}
if (cfg) {
cbm_config_close(cfg);
}
(void)cbm_chdir(old_cwd);
restore_cache_dir(saved_copy);
free(saved_copy);
th_cleanup(cache);
return calls;
}
#endif /* CBM_ENABLE_TEST_SEAMS */
#endif /* !_WIN32 */
TEST(mcp_ignore_worktrees_gates_explicit_index_repository) {
#ifdef _WIN32
SKIP_PLATFORM("git worktree fixture not implemented for Windows");
#else
int bits = ignore_worktrees_index_probe("true");
if (bits == -1) {
FAIL("th_mktempdir returned NULL");
}
if (bits == -2) {
FAIL("failed to create ignore_worktrees fixture directory");
}
if (bits < 0) {
SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");
}
/* RED before the gate existed: nothing is ever refused. */
ASSERT((bits & IGNORE_WT_REFUSED_WORKTREE) != 0);
ASSERT((bits & IGNORE_WT_REFUSED_MAIN) == 0);
ASSERT((bits & IGNORE_WT_REFUSED_OVERRIDE) == 0);
PASS();
#endif /* _WIN32 */
}
/* Default-off pin: key unset, linked worktree still indexes. The gate is
* opt-in; an unset key must be bit-for-bit today's behaviour. */
TEST(mcp_ignore_worktrees_default_off_still_indexes_worktree) {
#ifdef _WIN32
SKIP_PLATFORM("git worktree fixture not implemented for Windows");
#else
int bits = ignore_worktrees_index_probe(NULL);
if (bits == -1) {
FAIL("th_mktempdir returned NULL");
}
if (bits == -2) {
FAIL("failed to create ignore_worktrees fixture directory");
}
if (bits < 0) {
SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");
}
ASSERT((bits & IGNORE_WT_REFUSED_WORKTREE) == 0);
ASSERT((bits & IGNORE_WT_REFUSED_MAIN) == 0);
ASSERT((bits & IGNORE_WT_REFUSED_OVERRIDE) == 0);
PASS();
#endif /* _WIN32 */
}
#ifdef CBM_ENABLE_TEST_SEAMS
TEST(mcp_ignore_worktrees_skips_auto_index_on_linked_worktree) {
#ifdef _WIN32
SKIP_PLATFORM("git worktree fixture not implemented for Windows");
#else
ignore_wt_fixture_t fx;
int setup = ignore_wt_fixture_setup(&fx);
if (setup == -1) {
FAIL("th_mktempdir returned NULL");
}
if (setup == -2) {
FAIL("failed to create ignore_worktrees fixture directory");
}
if (setup < 0) {
SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");
}
int calls = ignore_wt_autoindex_count_calls(fx.wt_repo, "true");
ignore_wt_fixture_cleanup(&fx);
if (calls == -1) {
FAIL("th_mktempdir returned NULL");
}
if (calls < 0) {
FAIL("ignore_worktrees auto-index fixture failed");
}
ASSERT_EQ(calls, 0);
PASS();
#endif /* _WIN32 */
}
TEST(mcp_ignore_worktrees_default_off_auto_index_reaches_count) {
#ifdef _WIN32
SKIP_PLATFORM("git worktree fixture not implemented for Windows");
#else
ignore_wt_fixture_t fx;
int setup = ignore_wt_fixture_setup(&fx);
if (setup == -1) {
FAIL("th_mktempdir returned NULL");
}
if (setup == -2) {
FAIL("failed to create ignore_worktrees fixture directory");
}
if (setup < 0) {
SKIP_PLATFORM("git worktree add unavailable (git 2.5+ required)");
}
int calls = ignore_wt_autoindex_count_calls(fx.wt_repo, NULL);
ignore_wt_fixture_cleanup(&fx);
if (calls == -1) {
FAIL("th_mktempdir returned NULL");
}
if (calls < 0) {
FAIL("ignore_worktrees auto-index fixture failed");
}
ASSERT_EQ(calls, 1);
PASS();
#endif /* _WIN32 */
}
#endif /* CBM_ENABLE_TEST_SEAMS */
/* ══════════════════════════════════════════════════════════════════
* #1466 / #713 — the auto_index_limit guard
*
@@ -26751,6 +27544,7 @@ SUITE(mcp) {
/* MCP protocol helpers */
RUN_TEST(mcp_initialize_response);
RUN_TEST(mcp_ignore_worktrees_runtime_read_leaves_server_and_store_alone);
RUN_TEST(mcp_tools_list);
RUN_TEST(mcp_tools_help_list_matches_registry);
RUN_TEST(mcp_tools_list_latest_metadata);
@@ -26899,6 +27693,15 @@ SUITE(mcp) {
RUN_TEST(tool_responses_carry_store_generation_issue2585);
RUN_TEST(tool_check_index_coverage_surfaces_lookup_errors);
RUN_TEST(tool_index_status_includes_git_metadata);
RUN_TEST(tool_index_status_fails_closed_without_indexed_checkout_identity);
RUN_TEST(tool_index_status_omits_freshness_by_default);
RUN_TEST(tool_index_status_freshness_verdict_current_when_indexed_checkout_matches);
RUN_TEST(tool_index_status_freshness_verdict_stale_when_indexed_checkout_mismatches);
RUN_TEST(tool_index_status_freshness_verdict_stale_when_tracked_changes);
RUN_TEST(tool_index_status_freshness_verdict_unknown_when_untracked_only);
RUN_TEST(tool_index_status_freshness_verdict_stale_when_tracked_and_untracked);
RUN_TEST(tool_index_status_freshness_status_unavailable_non_git);
RUN_TEST(tool_index_status_freshness_sample_cap_truncates);
/* Tool handlers with validation */
RUN_TEST(tool_trace_path_recursion_metadata_issue2816);
@@ -27149,6 +27952,13 @@ SUITE(mcp) {
RUN_TEST(autoindex_limit_guards_non_git_root_issue713);
RUN_TEST(autoindex_limit_admits_non_git_root_under_limit_issue713);
RUN_TEST(autoindex_limit_guards_git_root_issue713);
/* ignore_worktrees gate */
RUN_TEST(mcp_ignore_worktrees_gates_explicit_index_repository);
RUN_TEST(mcp_ignore_worktrees_default_off_still_indexes_worktree);
#ifdef CBM_ENABLE_TEST_SEAMS
RUN_TEST(mcp_ignore_worktrees_skips_auto_index_on_linked_worktree);
RUN_TEST(mcp_ignore_worktrees_default_off_auto_index_reaches_count);
#endif
RUN_TEST(mcp_auto_index_in_process_fresh_project_uses_full_width);
RUN_TEST(mcp_auto_index_in_process_existing_index_keeps_headroom);
RUN_TEST(mcp_background_flag_fresh_project_uses_full_width);
tests/test_pipeline.c
+425 -2
View File
@@ -21140,8 +21140,9 @@ static int pyn_run_init_collision(int fillers) {
const char *project = cbm_pipeline_project_name(p);
imports[run] = pyn_edge(s, project, "tests.test_app.py.__file__",
"src.rowpkg.layout.Layout", "IMPORTS");
/* Layout defines __init__, so Layout("demo") targets it (#1642). */
calls[run] = pyn_edge(s, project, "tests.test_app.test_build",
"src.rowpkg.layout.Layout", "CALLS");
"src.rowpkg.layout.Layout.__init__", "CALLS");
method[run] = pyn_edge(s, project, "tests.test_app.test_build",
"src.rowpkg.layout.Layout.create", "CALLS");
cbm_store_close(s);
@@ -21160,7 +21161,7 @@ static int pyn_run_init_collision(int fillers) {
for (int run = 0; run < 2; run++) {
ASSERT_EQ(rc[run], 0);
ASSERT_TRUE(imports[run]); /* the class stays importable */
ASSERT_TRUE(calls[run]); /* Layout("demo") */
ASSERT_TRUE(calls[run]); /* Layout("demo") -> Layout.__init__ */
ASSERT_TRUE(method[run]); /* .create() through the constructed type */
}
PASS();
@@ -22228,6 +22229,423 @@ static int pipeline_legacy_c_identity_index_is_rebuilt(int legacy_version) {
PASS();
}
/* #759: index a Next.js App Router tree as project "nextjs" (a full index, or
* the incremental route a stored index of the same tree takes). */
static int nextjs_index(const char *repo, const char *db_path) {
cbm_pipeline_t *p = cbm_pipeline_new(repo, db_path, CBM_MODE_FULL);
if (!p) {
return -1;
}
(void)cbm_pipeline_set_project_name(p, "nextjs");
int rc = cbm_pipeline_run(p);
cbm_pipeline_free(p);
return rc;
}
/* Every Route of a stored index with each handler that HANDLES it, one sorted
* line each: "METHOD path route_qn file_path handler_qn". A Route no handler
* reaches ends in "-". The properties are parsed (json_extract): a Route not
* from route metadata is marked "!source", a handler declared in another file
* "!file", a HANDLES edge whose handler property is not its handler's QN
* "!handler"; malformed JSON fails the query. */
static bool nextjs_route_tuples(const char *db_path, char *out, size_t sz) {
sqlite3 *db = NULL;
sqlite3_stmt *st = NULL;
bool ok = false;
if (sqlite3_open_v2(db_path, &db, SQLITE_OPEN_READONLY, NULL) == SQLITE_OK &&
sqlite3_prepare_v2(
db,
"SELECT coalesce(group_concat(t, char(10)), '') FROM (SELECT "
"json_extract(r.properties,'$.method') || ' ' || r.name || ' ' || r.qualified_name || "
"' ' || r.file_path || ' ' || coalesce(h.qualified_name, '-') || CASE WHEN "
"json_extract(r.properties,'$.source') = 'decorator' THEN '' ELSE ' !source' END || "
"CASE WHEN h.id IS NULL OR h.file_path = r.file_path THEN '' ELSE ' !file' END || "
"CASE WHEN e.id IS NULL OR json_extract(e.properties,'$.handler') = h.qualified_name "
"THEN '' ELSE ' !handler' END AS t FROM nodes r LEFT JOIN edges e ON "
"e.target_id=r.id AND e.type='HANDLES' LEFT JOIN nodes h ON h.id=e.source_id WHERE "
"r.label='Route' ORDER BY t)",
-1, &st, NULL) == SQLITE_OK &&
sqlite3_step(st) == SQLITE_ROW) {
snprintf(out, sz, "%s", (const char *)sqlite3_column_text(st, 0));
ok = true;
}
sqlite3_finalize(st);
sqlite3_close(db);
return ok;
}
static int nextjs_by_qn(const void *a, const void *b) {
return strcmp(((const cbm_search_result_t *)a)->node.qualified_name,
((const cbm_search_result_t *)b)->node.qualified_name);
}
/* The Routes a search by label Route and declaring-file glob finds, one
* "qualified_name file_path" line each in QN order. */
static bool nextjs_found_routes(const char *db_path, const char *glob, char *out, size_t sz) {
cbm_store_t *s = cbm_store_open_path_existing(db_path);
if (!s) {
return false;
}
cbm_search_params_t params = {.project = "nextjs",
.label = "Route",
.file_pattern = glob,
.min_degree = -1,
.max_degree = -1,
.limit = 100};
cbm_search_output_t res = {0};
bool ok = cbm_store_search(s, &params, &res) == CBM_STORE_OK;
if (ok && res.count > 1) {
qsort(res.results, (size_t)res.count, sizeof(res.results[0]), nextjs_by_qn);
}
size_t len = 0;
out[0] = '\0';
for (int i = 0; ok && i < res.count; i++) {
int n = snprintf(out + len, sz - len, "%s%s %s", i ? "\n" : "",
res.results[i].node.qualified_name, res.results[i].node.file_path);
ok = n >= 0 && (size_t)n < sz - len;
len += ok ? (size_t)n : 0;
}
cbm_store_search_free(&res);
cbm_store_close(s);
return ok;
}
/* One index of a Next.js tree: its result, the route it took and the stored
* Routes after it (nextjs_route_tuples). */
typedef struct {
int rc;
cbm_incremental_route_t route;
bool read;
char tuples[1024];
} nextjs_run_t;
static void nextjs_run(const char *repo, const char *db_path, nextjs_run_t *run) {
run->rc = nextjs_index(repo, db_path);
run->route = cbm_pipeline_incremental_test_last_route();
run->read = nextjs_route_tuples(db_path, run->tuples, sizeof(run->tuples));
}
/* #759: the HTTP verb Functions a Next.js route file exports HANDLE the Routes
* its directories name, in the stored graph: a dynamic segment, a group, a
* catch-all and the root, under src/app/ and app/. Each Route is there once,
* with its file, from its own handler, whose HANDLES property is its QN. A
* search by label Route and the declaring file's glob finds them. `fillers`
* more files put the index on the parallel extraction path. */
static int nextjs_persisted_contract(int fillers) {
char tmp[256];
snprintf(tmp, sizeof(tmp), "/tmp/cbm_nextjs_routes_XXXXXX");
ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
for (int i = 0; i < fillers; i++) {
char name[64];
char body[128];
snprintf(name, sizeof(name), "lib/filler%d.ts", i);
snprintf(body, sizeof(body), "export function filler%d(): number {\n return %d;\n}\n", i,
i);
write_temp_file(tmp, name, body);
}
write_temp_file(tmp, "src/app/api/users/[id]/route.ts",
"export function GET() {\n return 1;\n}\n"
"export const POST = async () => 1;\n");
write_temp_file(tmp, "src/app/(public)/api/[org]/users/[id]/route.ts",
"export async function GET() {\n return 2;\n}\n");
write_temp_file(tmp, "app/api/[...slug]/route.ts", "export function GET() {\n return 3;\n}\n");
write_temp_file(tmp, "app/route.js", "export function GET() {\n return 4;\n}\n");
char db_path[512];
snprintf(db_path, sizeof(db_path), "%s/nextjs.db", tmp);
char *old_workers = getenv("CBM_WORKERS");
char *saved = old_workers ? strdup(old_workers) : NULL;
if (fillers > 0) {
cbm_setenv("CBM_WORKERS", "4", 1);
}
nextjs_run_t full;
nextjs_run(tmp, db_path, &full);
if (saved) {
cbm_setenv("CBM_WORKERS", saved, 1);
free(saved);
} else {
cbm_unsetenv("CBM_WORKERS");
}
char found[1024];
bool searched =
nextjs_found_routes(db_path, "src/app/api/users/*/route.ts", found, sizeof(found));
th_rmtree(tmp);
ASSERT_EQ(full.rc, 0);
ASSERT_TRUE(full.read);
ASSERT_STR_EQ(
full.tuples,
"GET / __route__GET__/ app/route.js nextjs.app.route.GET\n"
"GET /api/*slug __route__GET__/api/*slug app/api/[...slug]/route.ts "
"nextjs.app.api.[...slug].route.GET\n"
"GET /api/:org/users/:id __route__GET__/api/{}/users/{} "
"src/app/(public)/api/[org]/users/[id]/route.ts "
"nextjs.src.app.(public).api.[org].users.[id].route.GET\n"
"GET /api/users/:id __route__GET__/api/users/{} src/app/api/users/[id]/route.ts "
"nextjs.src.app.api.users.[id].route.GET\n"
"POST /api/users/:id __route__POST__/api/users/{} src/app/api/users/[id]/route.ts "
"nextjs.src.app.api.users.[id].route.POST");
ASSERT_TRUE(searched);
ASSERT_STR_EQ(found, "__route__GET__/api/users/{} src/app/api/users/[id]/route.ts\n"
"__route__POST__/api/users/{} src/app/api/users/[id]/route.ts");
PASS();
}
TEST(pipeline_nextjs_persisted_route_contract_issue759) {
return nextjs_persisted_contract(0);
}
TEST(pipeline_nextjs_persisted_route_contract_parallel_issue759) {
return nextjs_persisted_contract(52);
}
/* #759 over the life of a route file. Each step re-indexes the stored graph;
* after each, the file's current handlers are its only Routes, each once, and
* an unrelated route file keeps its Route. An unchanged tree is a no-op, and a
* change to another file rebuilds the unchanged route files' Routes from their
* stored handlers (pass_route_nodes.c), which a search still finds. */
TEST(pipeline_nextjs_incremental_lifecycle_issue759) {
char tmp[256];
snprintf(tmp, sizeof(tmp), "/tmp/cbm_nextjs_life_XXXXXX");
ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
write_temp_file(tmp, "app/api/items/route.ts",
"export function GET() {\n return 1;\n}\n"
"export async function POST() {\n return 2;\n}\n");
write_temp_file(tmp, "app/api/health/route.ts", "export const GET = () => 'ok';\n");
write_temp_file(tmp, "lib/helper.ts", "export function helper(): number {\n return 1;\n}\n");
char db_path[512];
snprintf(db_path, sizeof(db_path), "%s/nextjs.db", tmp);
nextjs_run_t full;
nextjs_run(tmp, db_path, &full);
nextjs_run_t same;
nextjs_run(tmp, db_path, &same);
char found_same[1024];
bool searched_same =
nextjs_found_routes(db_path, "app/api/*/route.ts", found_same, sizeof(found_same));
write_temp_file(tmp, "lib/helper.ts", "export function helper(): number {\n return 2;\n}\n");
nextjs_run_t helper_only;
nextjs_run(tmp, db_path, &helper_only);
char found_repair[1024];
bool searched_repair =
nextjs_found_routes(db_path, "app/api/*/route.ts", found_repair, sizeof(found_repair));
write_temp_file(tmp, "app/api/items/route.ts", "export function GET() {\n return 1;\n}\n");
nextjs_run_t no_post;
nextjs_run(tmp, db_path, &no_post);
write_temp_file(tmp, "app/api/items/route.ts",
"export function GET() {\n const n = 10;\n return n;\n}\n");
nextjs_run_t new_body;
nextjs_run(tmp, db_path, &new_body);
write_temp_file(tmp, "app/api/items/route.ts", "export function PATCH() {\n return 3;\n}\n");
nextjs_run_t patch;
nextjs_run(tmp, db_path, &patch);
write_temp_file(tmp, "app/api/products/route.ts",
"export function PATCH() {\n return 3;\n}\n");
stem_unlink(tmp, "app/api/items/route.ts");
nextjs_run_t moved;
nextjs_run(tmp, db_path, &moved);
write_temp_file(tmp, "app/api/products/[id]/route.ts",
"export function PATCH() {\n return 3;\n}\n");
stem_unlink(tmp, "app/api/products/route.ts");
nextjs_run_t dynamic;
nextjs_run(tmp, db_path, &dynamic);
stem_unlink(tmp, "app/api/products/[id]/route.ts");
nextjs_run_t deleted;
nextjs_run(tmp, db_path, &deleted);
th_rmtree(tmp);
static const char health[] = "GET /api/health __route__GET__/api/health "
"app/api/health/route.ts nextjs.app.api.health.route.GET";
static const char routes[] = "GET /api/health __route__GET__/api/health "
"app/api/health/route.ts nextjs.app.api.health.route.GET\n"
"GET /api/items __route__GET__/api/items app/api/items/route.ts "
"nextjs.app.api.items.route.GET\n"
"POST /api/items __route__POST__/api/items app/api/items/route.ts "
"nextjs.app.api.items.route.POST";
static const char get_only[] = "GET /api/health __route__GET__/api/health "
"app/api/health/route.ts nextjs.app.api.health.route.GET\n"
"GET /api/items __route__GET__/api/items app/api/items/route.ts "
"nextjs.app.api.items.route.GET";
ASSERT_EQ(full.rc, 0);
ASSERT_TRUE(full.read);
ASSERT_STR_EQ(full.tuples, routes);
ASSERT_EQ(same.rc, 0);
ASSERT_EQ(same.route, CBM_INCREMENTAL_ROUTE_NOOP);
ASSERT_STR_EQ(same.tuples, routes);
ASSERT_TRUE(searched_same);
ASSERT_STR_EQ(found_same, "__route__GET__/api/health app/api/health/route.ts\n"
"__route__GET__/api/items app/api/items/route.ts\n"
"__route__POST__/api/items app/api/items/route.ts");
ASSERT_EQ(helper_only.rc, 0);
ASSERT_EQ(helper_only.route, CBM_INCREMENTAL_ROUTE_CLOSURE_REPAIR);
ASSERT_STR_EQ(helper_only.tuples, routes);
ASSERT_TRUE(searched_repair);
ASSERT_STR_EQ(found_repair, found_same);
ASSERT_EQ(no_post.rc, 0);
ASSERT_EQ(no_post.route, CBM_INCREMENTAL_ROUTE_CLOSURE_REPAIR);
ASSERT_STR_EQ(no_post.tuples, get_only);
ASSERT_EQ(new_body.rc, 0);
ASSERT_EQ(new_body.route, CBM_INCREMENTAL_ROUTE_CLOSURE_REPAIR);
ASSERT_STR_EQ(new_body.tuples, get_only);
ASSERT_EQ(patch.rc, 0);
ASSERT_STR_EQ(patch.tuples, "GET /api/health __route__GET__/api/health "
"app/api/health/route.ts nextjs.app.api.health.route.GET\n"
"PATCH /api/items __route__PATCH__/api/items "
"app/api/items/route.ts nextjs.app.api.items.route.PATCH");
ASSERT_EQ(moved.rc, 0);
ASSERT_STR_EQ(moved.tuples, "GET /api/health __route__GET__/api/health "
"app/api/health/route.ts nextjs.app.api.health.route.GET\n"
"PATCH /api/products __route__PATCH__/api/products "
"app/api/products/route.ts nextjs.app.api.products.route.PATCH");
ASSERT_EQ(dynamic.rc, 0);
ASSERT_STR_EQ(dynamic.tuples,
"GET /api/health __route__GET__/api/health "
"app/api/health/route.ts nextjs.app.api.health.route.GET\n"
"PATCH /api/products/:id __route__PATCH__/api/products/{} "
"app/api/products/[id]/route.ts nextjs.app.api.products.[id].route.PATCH");
ASSERT_EQ(deleted.rc, 0);
ASSERT_STR_EQ(deleted.tuples, health);
PASS();
}
/* CBM_SEMANTIC_INDEX_VERSION 13 (#759): an index version 12 wrote has no route
* metadata, Route or HANDLES for a Next.js route file, and an unchanged tree
* is otherwise a no-op, so the version is what makes the new binary rebuild
* it. The stored index is put back to the version-12 state by hand (metadata,
* the handlers' route properties, the Routes and their edges); the run after
* that must replace it in full, the next one is a no-op. */
TEST(pipeline_nextjs_semantic_upgrade_issue759) {
char tmp[256];
snprintf(tmp, sizeof(tmp), "/tmp/cbm_nextjs_upgrade_XXXXXX");
ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
write_temp_file(tmp, "app/api/items/route.ts",
"export function GET() {\n return 1;\n}\n"
"export const POST = async () => 2;\n");
write_temp_file(tmp, "lib/helper.ts", "export function helper(): number {\n return 1;\n}\n");
char db_path[512];
snprintf(db_path, sizeof(db_path), "%s/nextjs.db", tmp);
static const char all_nodes[] = "SELECT COUNT(*) FROM nodes";
static const char all_edges[] = "SELECT COUNT(*) FROM edges";
static const char routed[] =
"SELECT COUNT(*) FROM nodes WHERE json_extract(properties,'$.route_path') IS NOT NULL";
nextjs_run_t full;
nextjs_run(tmp, db_path, &full);
int nodes_before = k8s_inc_count(db_path, all_nodes);
int edges_before = k8s_inc_count(db_path, all_edges);
/* Put the published index back to what version 12 wrote. */
cbm_store_t *store = cbm_store_open_path(db_path);
ASSERT_NOT_NULL(store);
cbm_coverage_row_t *coverage_rows = NULL;
int coverage_count = 0;
ASSERT_EQ(cbm_store_coverage_get(store, "nextjs", &coverage_rows, &coverage_count),
CBM_STORE_OK);
cbm_coverage_meta_t meta = {0};
ASSERT_EQ(cbm_store_coverage_meta_get(store, "nextjs", &meta), CBM_STORE_OK);
cbm_coverage_meta_t old_meta = meta;
old_meta.coverage_version = 12;
ASSERT_EQ(
cbm_store_coverage_replace_ex(store, "nextjs", coverage_rows, coverage_count, &old_meta),
CBM_STORE_OK);
cbm_store_free_coverage(coverage_rows, coverage_count);
cbm_store_coverage_meta_clear(&meta);
ASSERT_EQ(cbm_store_exec(store,
"DELETE FROM edges WHERE source_id IN (SELECT id FROM nodes WHERE "
"label = 'Route') OR target_id IN (SELECT id FROM nodes WHERE "
"label = 'Route');"
"DELETE FROM nodes WHERE label = 'Route';"
"UPDATE nodes SET properties = json_remove(properties, "
"'$.route_path', '$.route_method') "
"WHERE json_extract(properties, '$.route_path') IS NOT NULL;"),
CBM_STORE_OK);
cbm_store_close(store);
nextjs_run_t version_12 = {0};
version_12.read = nextjs_route_tuples(db_path, version_12.tuples, sizeof(version_12.tuples));
int routed_12 = k8s_inc_count(db_path, routed);
/* Nothing in the tree changed: only the version says the index is stale. */
nextjs_run_t upgrade;
nextjs_run(tmp, db_path, &upgrade);
int nodes_after = k8s_inc_count(db_path, all_nodes);
int edges_after = k8s_inc_count(db_path, all_edges);
int routed_after = k8s_inc_count(db_path, routed);
store = cbm_store_open_path(db_path);
ASSERT_NOT_NULL(store);
cbm_coverage_meta_t new_meta = {0};
ASSERT_EQ(cbm_store_coverage_meta_get(store, "nextjs", &new_meta), CBM_STORE_OK);
int stored_version = new_meta.coverage_version;
cbm_store_coverage_meta_clear(&new_meta);
cbm_store_close(store);
nextjs_run_t again;
nextjs_run(tmp, db_path, &again);
th_rmtree(tmp);
ASSERT_EQ(full.rc, 0);
ASSERT_STR_EQ(full.tuples, "GET /api/items __route__GET__/api/items app/api/items/route.ts "
"nextjs.app.api.items.route.GET\n"
"POST /api/items __route__POST__/api/items app/api/items/route.ts "
"nextjs.app.api.items.route.POST");
ASSERT_TRUE(version_12.read);
ASSERT_STR_EQ(version_12.tuples, "");
ASSERT_EQ(routed_12, 0);
ASSERT_EQ(upgrade.rc, 0);
ASSERT_EQ(upgrade.route, CBM_INCREMENTAL_ROUTE_FORCED_FULL);
ASSERT_STR_EQ(upgrade.tuples, full.tuples);
ASSERT_EQ(routed_after, 2);
ASSERT_EQ(nodes_after, nodes_before);
ASSERT_EQ(edges_after, edges_before);
ASSERT_EQ(stored_version, CBM_SEMANTIC_INDEX_VERSION);
ASSERT_EQ(again.rc, 0);
ASSERT_EQ(again.route, CBM_INCREMENTAL_ROUTE_NOOP);
ASSERT_STR_EQ(again.tuples, full.tuples);
ASSERT_GTE(CBM_SEMANTIC_INDEX_VERSION, 13);
PASS();
}
/* #759: a quote is legal in a POSIX directory name, so a route path, its file
* and its handler's QN can hold one, escaped in the stored JSON. The route pass
* builds the Route from its handler's stored properties on every index
* (pass_route_nodes.c), so the full index and an incremental one after an
* unrelated edit must both store it intact. */
TEST(pipeline_nextjs_quoted_route_round_trip_issue759) {
#ifdef _WIN32
SKIP_PLATFORM("a quote is not a legal Windows path character");
#else
char tmp[256];
snprintf(tmp, sizeof(tmp), "/tmp/cbm_nextjs_quote_XXXXXX");
ASSERT_NOT_NULL(cbm_mkdtemp(tmp));
write_temp_file(tmp, "app/api/a\"b/route.ts", "export function GET() {\n return 1;\n}\n");
write_temp_file(tmp, "lib/helper.ts", "export function helper(): number {\n return 1;\n}\n");
char db_path[512];
snprintf(db_path, sizeof(db_path), "%s/nextjs.db", tmp);
nextjs_run_t full;
nextjs_run(tmp, db_path, &full);
write_temp_file(tmp, "lib/helper.ts", "export function helper(): number {\n return 2;\n}\n");
nextjs_run_t helper_only;
nextjs_run(tmp, db_path, &helper_only);
th_rmtree(tmp);
ASSERT_EQ(full.rc, 0);
ASSERT_TRUE(full.read);
ASSERT_STR_EQ(full.tuples, "GET /api/a\"b __route__GET__/api/a\"b app/api/a\"b/route.ts "
"nextjs.app.api.a\"b.route.GET");
ASSERT_EQ(helper_only.rc, 0);
ASSERT_EQ(helper_only.route, CBM_INCREMENTAL_ROUTE_CLOSURE_REPAIR);
ASSERT_TRUE(helper_only.read);
ASSERT_STR_EQ(helper_only.tuples, full.tuples);
PASS();
#endif
}
TEST(pipeline_semantic_version_3_index_is_rebuilt_in_full_c1) {
return pipeline_legacy_c_identity_index_is_rebuilt(3);
}
@@ -31201,6 +31619,11 @@ SUITE(pipeline) {
RUN_TEST(pipeline_cpp_overloads_are_listed_as_variants_c1);
RUN_TEST(pipeline_semantic_version_3_index_is_rebuilt_in_full_c1);
RUN_TEST(pipeline_semantic_version_5_index_is_rebuilt_in_full_c1);
RUN_TEST(pipeline_nextjs_persisted_route_contract_issue759);
RUN_TEST(pipeline_nextjs_persisted_route_contract_parallel_issue759);
RUN_TEST(pipeline_nextjs_incremental_lifecycle_issue759);
RUN_TEST(pipeline_nextjs_semantic_upgrade_issue759);
RUN_TEST(pipeline_nextjs_quoted_route_round_trip_issue759);
RUN_TEST(pipeline_python_app_factory_routes_issue1548);
RUN_TEST(pipeline_python_nested_def_is_function_local_issue1548);
RUN_TEST(pipeline_python_local_classes_stay_in_their_def_issue1548);
tests/test_platform.c
+47
View File
@@ -16,6 +16,9 @@
#include <unistd.h>
#ifndef _WIN32
#include <sys/stat.h> /* chmod for the symlink-policy mode legs */
#include <errno.h>
#include <sys/resource.h> /* getpriority for the worker-priority leg */
#include <sys/wait.h>
#endif
#ifdef __linux__
@@ -1442,6 +1445,49 @@ TEST(regex_estimate_counts_brackets_and_escapes_literally) {
PASS();
}
/* An index worker lowers its own priority (#2834). A non-root process cannot
* raise it back, so the helper runs in a forked child that reports its nice. */
TEST(platform_lower_cpu_priority_nices_the_process) {
#ifdef _WIN32
SKIP_PLATFORM("POSIX nice contract");
#else
int fds[2];
ASSERT_EQ(pipe(fds), 0);
pid_t child = fork();
if (child == 0) {
(void)close(fds[0]);
/* report: lowered ok, nice after; then, from a nicer start, ok, target, nice after */
int report[5] = {cbm_lower_cpu_priority() ? 1 : 0, 0, 0, 0, 0};
errno = 0;
report[1] = getpriority(PRIO_PROCESS, 0);
if (errno != 0) {
report[0] = 0;
}
/* Never-raise leg: start nicer than the helper's level; it must leave it. */
report[3] = report[1] >= 15 ? 19 : 15;
if (setpriority(PRIO_PROCESS, 0, report[3]) == 0) {
report[2] = cbm_lower_cpu_priority() ? 1 : 0;
errno = 0;
report[4] = getpriority(PRIO_PROCESS, 0);
}
_exit(write(fds[1], report, sizeof(report)) == (ssize_t)sizeof(report) ? 0 : 1);
}
ASSERT_TRUE(child > 0);
(void)close(fds[1]);
int report[5] = {0, 0, 0, 0, 0};
ssize_t got = read(fds[0], report, sizeof(report));
(void)close(fds[0]);
int status = 0;
(void)waitpid(child, &status, 0);
ASSERT_EQ(got, (ssize_t)sizeof(report));
ASSERT_EQ(report[0], 1);
ASSERT_TRUE(report[1] >= CBM_LOW_CPU_PRIORITY_NICE);
ASSERT_EQ(report[2], 1);
ASSERT_EQ(report[4], report[3]);
PASS();
#endif
}
SUITE(platform) {
RUN_TEST(platform_file_apis_survive_max_path_overflow);
RUN_TEST(platform_mkdir_p_follows_own_symlink_only_when_opted_in);
@@ -1477,6 +1523,7 @@ SUITE(platform) {
RUN_TEST(platform_env_long_refuses_what_it_cannot_read);
RUN_TEST(platform_env_dup_honours_the_settings_resolver);
RUN_TEST(platform_system_info);
RUN_TEST(platform_lower_cpu_priority_nices_the_process);
RUN_TEST(regex_compile_refuses_oversized_expansion);
RUN_TEST(regex_compile_accepts_expansion_under_budget);
RUN_TEST(regex_compile_refuses_overlong_pattern);
tests/test_py_lsp.c
+292
View File
@@ -356,6 +356,193 @@ TEST(pylsp_constructor_call_returns_instance) {
PASS();
}
/* Issue #1642: Embedder(...) must resolve to Embedder.__init__, and the
* textual callee leaf "Embedder" must still join that row. */
TEST(pylsp_constructor_call_targets_init) {
const char *source = "class Embedder:\n"
" def __init__(self, model=\"x\"):\n"
" self.model = model\n"
"def build():\n"
" return Embedder(model=\"y\")\n";
CBMFileResult *r = extract_py(source);
ASSERT_NOT_NULL(r);
int idx = require_resolved(r, "build", "Embedder.__init__");
ASSERT_GTE(idx, 0);
if (idx >= 0) {
const CBMResolvedCall *rc = &r->resolved_calls.items[idx];
ASSERT_STR_EQ(rc->strategy, "lsp_constructor_init");
ASSERT_STR_EQ(rc->reason, "Embedder");
ASSERT(strncmp(rc->callee_qn, "builtins.", 9) != 0);
}
for (int i = 0; i < r->resolved_calls.count; i++) {
const CBMResolvedCall *rc = &r->resolved_calls.items[i];
if (rc->kind != CBM_RESOLVED_INVOCATION || !rc->caller_qn || !rc->callee_qn ||
!strstr(rc->caller_qn, "build"))
continue;
/* One site, one target: the class node no longer receives the call. */
ASSERT(strstr(rc->callee_qn, ".__init__") != NULL);
ASSERT(strncmp(rc->callee_qn, "builtins.", 9) != 0);
}
const CBMCall *carrier = NULL;
for (int i = 0; i < r->calls.count; i++) {
const CBMCall *call = &r->calls.items[i];
if (call->callee_name && strcmp(call->callee_name, "Embedder") == 0 &&
call->enclosing_func_qn && strstr(call->enclosing_func_qn, "build")) {
carrier = call;
break;
}
}
ASSERT_NOT_NULL(carrier);
const CBMResolvedCall *joined =
cbm_pipeline_find_lsp_resolution(&r->resolved_calls, carrier, false);
ASSERT_NOT_NULL(joined);
ASSERT(strstr(joined->callee_qn, "Embedder.__init__") != NULL);
ASSERT_STR_EQ(joined->strategy, "lsp_constructor_init");
cbm_free_result(r);
PASS();
}
/* Same-file subclasses: only an __init__ the class declares itself is a
* construction target. B(A) inherits A.__init__ but declares none, so B()
* stays on the class B (never A.__init__). C(A) declares its own __init__,
* so C() resolves to C.__init__ (never the inherited A.__init__). */
static int count_build_rows(const CBMFileResult *r, const char *caller_leaf,
const char *callee_qn, const char *strategy) {
int n = 0;
for (int i = 0; i < r->resolved_calls.count; i++) {
const CBMResolvedCall *rc = &r->resolved_calls.items[i];
if (rc->kind != CBM_RESOLVED_INVOCATION || !rc->caller_qn || !rc->callee_qn ||
!rc->strategy)
continue;
const char *dot = strrchr(rc->caller_qn, '.');
const char *leaf = dot ? dot + 1 : rc->caller_qn;
if (strcmp(leaf, caller_leaf) == 0 && strcmp(rc->callee_qn, callee_qn) == 0 &&
strcmp(rc->strategy, strategy) == 0)
n++;
}
return n;
}
TEST(pylsp_constructor_same_file_subclass_own_init_only) {
CBMFileResult *r = extract_py("class A:\n"
" def __init__(self):\n"
" self.ready = True\n"
"class B(A):\n"
" def go(self):\n"
" return 1\n"
"class C(A):\n"
" def __init__(self):\n"
" self.ready = False\n"
"def build_b():\n"
" return B()\n"
"def build_c():\n"
" return C()\n");
ASSERT_NOT_NULL(r);
/* B() keeps the class target; the inherited A.__init__ gets no row. */
ASSERT_EQ(count_build_rows(r, "build_b", "test.main.B", "lsp_constructor"), 1);
ASSERT_EQ(find_resolved(r, "build_b", "__init__"), -1);
/* C() binds to the __init__ C declares itself. */
int idx = require_resolved(r, "build_c", "test.main.C.__init__");
ASSERT_GTE(idx, 0);
if (idx >= 0) {
const CBMResolvedCall *rc = &r->resolved_calls.items[idx];
ASSERT_STR_EQ(rc->strategy, "lsp_constructor_init");
ASSERT_STR_EQ(rc->reason, "C");
}
ASSERT_EQ(find_resolved(r, "build_c", "test.main.A.__init__"), -1);
ASSERT_EQ(count_build_rows(r, "build_c", "test.main.C", "lsp_constructor"), 0);
cbm_free_result(r);
PASS();
}
/* No user __init__ (and no inherited one): the call stays on the class. */
TEST(pylsp_constructor_without_init_stays_on_class) {
CBMFileResult *r = extract_py("class Bare:\n"
" def method(self):\n"
" return 1\n"
"def build():\n"
" return Bare()\n");
ASSERT_NOT_NULL(r);
ASSERT_EQ(find_resolved(r, "build", "__init__"), -1);
int idx = -1;
for (int i = 0; i < r->resolved_calls.count; i++) {
const CBMResolvedCall *rc = &r->resolved_calls.items[i];
if (rc->kind == CBM_RESOLVED_INVOCATION && rc->caller_qn &&
strstr(rc->caller_qn, "build") && rc->callee_qn && strstr(rc->callee_qn, "Bare") &&
!strstr(rc->callee_qn, "__init__")) {
idx = i;
break;
}
}
ASSERT_GTE(idx, 0);
if (idx >= 0)
ASSERT_STR_EQ(r->resolved_calls.items[idx].strategy, "lsp_constructor");
cbm_free_result(r);
PASS();
}
/* f = Foo(); f() is a callable instance, not a constructor. It must not
* gain an edge to Foo.__init__. Foo() itself still does. */
TEST(pylsp_callable_instance_call_skips_init) {
CBMFileResult *r = extract_py("class Foo:\n"
" def __init__(self):\n"
" pass\n"
" def __call__(self):\n"
" return 1\n"
"def use():\n"
" f = Foo()\n"
" return f()\n");
ASSERT_NOT_NULL(r);
int init_rows = 0;
int class_rows = 0;
for (int i = 0; i < r->resolved_calls.count; i++) {
const CBMResolvedCall *rc = &r->resolved_calls.items[i];
if (rc->kind != CBM_RESOLVED_INVOCATION || !rc->caller_qn || !rc->callee_qn ||
!strstr(rc->caller_qn, "use"))
continue;
if (strstr(rc->callee_qn, "__init__")) {
init_rows++;
ASSERT_STR_EQ(rc->strategy, "lsp_constructor_init");
ASSERT_STR_EQ(rc->reason, "Foo");
ASSERT(strncmp(rc->callee_qn, "builtins.", 9) != 0);
} else if (strstr(rc->callee_qn, "Foo")) {
class_rows++;
ASSERT_STR_EQ(rc->strategy, "lsp_constructor");
ASSERT_NULL(rc->reason);
}
}
ASSERT_EQ(init_rows, 1);
ASSERT_EQ(class_rows, 1);
cbm_free_result(r);
PASS();
}
/* builtins.object.__init__ is in the stdlib registry. Construction must not
* record a resolution to it. */
TEST(pylsp_constructor_skips_builtin_init) {
CBMFileResult *r = extract_py("from builtins import object\n"
"def build():\n"
" return object()\n");
ASSERT_NOT_NULL(r);
for (int i = 0; i < r->resolved_calls.count; i++) {
const CBMResolvedCall *rc = &r->resolved_calls.items[i];
if (!rc->callee_qn)
continue;
ASSERT(strncmp(rc->callee_qn, "builtins.", 9) != 0 ||
strstr(rc->callee_qn, ".__init__") == NULL);
}
int idx = find_resolved(r, "build", "builtins.object");
ASSERT_GTE(idx, 0);
if (idx >= 0) {
const CBMResolvedCall *rc = &r->resolved_calls.items[idx];
ASSERT_STR_EQ(rc->strategy, "lsp_constructor");
ASSERT(strstr(rc->callee_qn, "__init__") == NULL);
}
cbm_free_result(r);
PASS();
}
TEST(pylsp_method_via_inheritance) {
CBMFileResult *r = extract_py(
"class Base:\n"
@@ -924,6 +1111,104 @@ TEST(pylsp_crossfile_inheritance) {
PASS();
}
/* Imported ClassName() resolves to that class's __init__. Bare names are
* module-qualified during per-file registration, so the imported class has
* to come from the cross-file registry. */
TEST(pylsp_crossfile_constructor_targets_init) {
const char *source = "from models import Embedder\n"
"def build():\n"
" return Embedder(model=\"y\")\n";
CBMLSPDef defs[2];
memset(defs, 0, sizeof(defs));
defs[0].qualified_name = "models.Embedder";
defs[0].short_name = "Embedder";
defs[0].label = "Class";
defs[0].def_module_qn = "models";
defs[0].lang = CBM_LANG_PYTHON;
defs[1].qualified_name = "models.Embedder.__init__";
defs[1].short_name = "__init__";
defs[1].label = "Method";
defs[1].receiver_type = "models.Embedder";
defs[1].def_module_qn = "models";
defs[1].lang = CBM_LANG_PYTHON;
const char *imp_names[] = {"Embedder"};
const char *imp_qns[] = {"models.Embedder"};
CBMArena arena;
cbm_arena_init(&arena);
CBMTypeRegistry *reg = cbm_py_build_cross_registry(&arena, defs, 2);
ASSERT_NOT_NULL(reg);
CBMResolvedCallArray out = {0};
cbm_run_py_lsp_cross_with_registry(&arena, source, (int)strlen(source), "test.main", reg,
imp_names, imp_qns, 1, NULL, &out, NULL);
int idx = find_resolved_arr(&out, "build", "models.Embedder.__init__");
ASSERT_GTE(idx, 0);
if (idx >= 0) {
ASSERT_STR_EQ(out.items[idx].strategy, "lsp_constructor_init");
ASSERT_STR_EQ(out.items[idx].reason, "Embedder");
ASSERT(strncmp(out.items[idx].callee_qn, "builtins.", 9) != 0);
}
cbm_arena_destroy(&arena);
PASS();
}
/* class B(A) where A's __init__ lives in another module and B declares no
* __init__ of its own. Construction binds only to an __init__ the class
* declares itself, so B() stays on the class B and the inherited
* base_mod.A.__init__ gets no row. */
TEST(pylsp_crossfile_inherited_init_stays_on_class) {
const char *source = "from base_mod import A\n"
"class B(A):\n"
" def go(self):\n"
" return 1\n"
"def build():\n"
" return B()\n";
CBMLSPDef defs[3];
memset(defs, 0, sizeof(defs));
defs[0].qualified_name = "base_mod.A";
defs[0].short_name = "A";
defs[0].label = "Class";
defs[0].def_module_qn = "base_mod";
defs[0].lang = CBM_LANG_PYTHON;
defs[1].qualified_name = "base_mod.A.__init__";
defs[1].short_name = "__init__";
defs[1].label = "Method";
defs[1].receiver_type = "base_mod.A";
defs[1].def_module_qn = "base_mod";
defs[1].lang = CBM_LANG_PYTHON;
defs[2].qualified_name = "test.main.B";
defs[2].short_name = "B";
defs[2].label = "Class";
defs[2].def_module_qn = "test.main";
defs[2].embedded_types = "base_mod.A";
defs[2].lang = CBM_LANG_PYTHON;
const char *imp_names[] = {"A"};
const char *imp_qns[] = {"base_mod.A"};
CBMArena arena;
cbm_arena_init(&arena);
CBMTypeRegistry *reg = cbm_py_build_cross_registry(&arena, defs, 3);
ASSERT_NOT_NULL(reg);
CBMResolvedCallArray out = {0};
cbm_run_py_lsp_cross_with_registry(&arena, source, (int)strlen(source), "test.main", reg,
imp_names, imp_qns, 1, NULL, &out, NULL);
ASSERT_EQ(find_resolved_arr(&out, "build", "__init__"), -1);
int idx = find_resolved_arr(&out, "build", "test.main.B");
ASSERT_GTE(idx, 0);
if (idx >= 0) {
ASSERT_STR_EQ(out.items[idx].callee_qn, "test.main.B");
ASSERT_STR_EQ(out.items[idx].strategy, "lsp_constructor");
}
cbm_arena_destroy(&arena);
PASS();
}
TEST(pylsp_batch_two_files) {
const char *src_a =
"def helper():\n"
@@ -5010,6 +5295,11 @@ SUITE(py_lsp) {
RUN_TEST(pylsp_method_call_simple);
RUN_TEST(pylsp_method_via_self);
RUN_TEST(pylsp_constructor_call_returns_instance);
RUN_TEST(pylsp_constructor_call_targets_init);
RUN_TEST(pylsp_constructor_same_file_subclass_own_init_only);
RUN_TEST(pylsp_constructor_without_init_stays_on_class);
RUN_TEST(pylsp_callable_instance_call_skips_init);
RUN_TEST(pylsp_constructor_skips_builtin_init);
RUN_TEST(pylsp_method_via_inheritance);
RUN_TEST(pylsp_no_false_positive_on_unknown_method);
/* Phases 7-8 — decorators, super(), multi-inheritance */
@@ -5028,6 +5318,8 @@ SUITE(py_lsp) {
RUN_TEST(pylsp_cross_registry_interleaved_order);
RUN_TEST(pylsp_crossfile_classmethod_on_class_issue228);
RUN_TEST(pylsp_crossfile_inheritance);
RUN_TEST(pylsp_crossfile_constructor_targets_init);
RUN_TEST(pylsp_crossfile_inherited_init_stays_on_class);
RUN_TEST(pylsp_batch_two_files);
RUN_TEST(pylsp_from_import_alias_equal_module_leaf_targets_imported_member);
RUN_TEST(pylsp_project_prefixed_direct_alias_same_tail_is_not_from_import_reference);
tests/test_ruby_lsp.c
+1566
View File
File diff suppressed because it is too large. Load diff
tests/test_store_graph_digest.c
+40
View File
@@ -683,6 +683,45 @@ TEST(store_graph_digest_concurrent_isolation_with_held_callback_gates) {
cbm_store_close(a);cbm_store_close(b);PASS();
}
/* BT-240 (#1561): the indexed checkout is source identity, which the digest
* never binds, so it lives outside the digested tables. A store written through
* the real coverage API, with and without a checkout SHA, keeps passing the
* live-schema check (test-impact falls back to running everything otherwise),
* and recording or changing the SHA leaves the digest unchanged. */
TEST(store_graph_digest_indexed_checkout_identity_is_not_bound) {
cbm_store_t *s = cbm_store_open_memory();
ASSERT_NOT_NULL(s);
ASSERT_EQ(cbm_store_upsert_project(s, "p", "/live"), CBM_STORE_OK);
cbm_coverage_meta_t meta = {.generation = "g",
.index_mode = "full",
.recorded_at = "t",
.recording_status = "complete",
.coverage_version = 1,
.hash_records_complete = true};
cbm_store_graph_digest_t none = {0}, first = {0}, second = {0};
ASSERT_EQ(cbm_store_coverage_replace_ex(s, "p", NULL, 0, &meta), CBM_STORE_OK);
bool none_ok = gd_p(s, &none);
meta.indexed_checkout_sha = "0123456789abcdef0123456789abcdef01234567";
ASSERT_EQ(cbm_store_coverage_replace_ex(s, "p", NULL, 0, &meta), CBM_STORE_OK);
bool first_ok = gd_p(s, &first);
meta.indexed_checkout_sha = "89abcdef0123456789abcdef0123456789abcdef";
ASSERT_EQ(cbm_store_coverage_replace_ex(s, "p", NULL, 0, &meta), CBM_STORE_OK);
bool second_ok = gd_p(s, &second);
cbm_coverage_meta_t got = {0};
int got_rc = cbm_store_coverage_meta_get(s, "p", &got);
bool sha_kept = got_rc == CBM_STORE_OK && got.indexed_checkout_sha &&
strcmp(got.indexed_checkout_sha, "89abcdef0123456789abcdef0123456789abcdef") == 0;
cbm_store_coverage_meta_clear(&got);
cbm_store_close(s);
ASSERT_TRUE(none_ok);
ASSERT_TRUE(first_ok);
ASSERT_TRUE(second_ok);
ASSERT_TRUE(sha_kept);
ASSERT_TRUE(gd_equal(&none, &first));
ASSERT_TRUE(gd_equal(&first, &second));
PASS();
}
SUITE(store_graph_digest) {
RUN_TEST(store_graph_digest_binds_unresolved_candidate_index);
RUN_TEST(store_graph_digest_candidate_index_errors_are_not_legacy_absence);
@@ -699,4 +738,5 @@ SUITE(store_graph_digest) {
RUN_TEST(store_graph_digest_cancellation_large_blob_never_publishes_prefix);
RUN_TEST(store_graph_digest_sql_errors_cleanup_no_mutation_and_close_discard);
RUN_TEST(store_graph_digest_concurrent_isolation_with_held_callback_gates);
RUN_TEST(store_graph_digest_indexed_checkout_identity_is_not_bound);
}
tests/test_store_nodes.c
+70
View File
@@ -2706,6 +2706,75 @@ TEST(store_coverage_shadow_excludes_unresolved_calls) {
PASS();
}
TEST(store_coverage_meta_indexed_checkout_sha_roundtrip_and_rollback) {
cbm_store_t *s = cbm_store_open_memory();
ASSERT_NOT_NULL(s);
ASSERT_EQ(cbm_store_upsert_project(s, "coverage-sha", "/tmp/coverage-sha"), CBM_STORE_OK);
ASSERT_EQ(cbm_store_upsert_file_hash(s, "coverage-sha", "keep.c", "", 1, 1), CBM_STORE_OK);
cbm_coverage_row_t row = {.rel_path = "keep.c", .kind = "parse_partial", .detail = "1-2"};
/* NULL indexed_checkout_sha (non-git run) persists as NULL and reads back
* as no identity. */
cbm_coverage_meta_t no_sha_meta = {
.generation = "gen-0",
.index_mode = "full",
.recording_status = "complete",
.coverage_version = 1,
.hash_records_complete = true,
};
ASSERT_EQ(cbm_store_coverage_replace_ex(s, "coverage-sha", &row, 1, &no_sha_meta),
CBM_STORE_OK);
cbm_coverage_meta_t got = {0};
ASSERT_EQ(cbm_store_coverage_meta_get(s, "coverage-sha", &got), CBM_STORE_OK);
ASSERT_NULL(got.indexed_checkout_sha);
cbm_store_coverage_meta_clear(&got);
/* Round-trip: git-run identity persists and can be overwritten by the next
* staged generation. */
cbm_coverage_meta_t sha_meta = no_sha_meta;
sha_meta.generation = "gen-1";
sha_meta.indexed_checkout_sha = "0123456789abcdef0123456789abcdef01234567";
ASSERT_EQ(cbm_store_coverage_replace_ex(s, "coverage-sha", &row, 1, &sha_meta),
CBM_STORE_OK);
got = (cbm_coverage_meta_t){0};
ASSERT_EQ(cbm_store_coverage_meta_get(s, "coverage-sha", &got), CBM_STORE_OK);
ASSERT_STR_EQ(got.indexed_checkout_sha, "0123456789abcdef0123456789abcdef01234567");
ASSERT_STR_EQ(got.generation, "gen-1");
cbm_store_coverage_meta_clear(&got);
cbm_coverage_meta_t new_meta = sha_meta;
new_meta.generation = "gen-2";
new_meta.indexed_checkout_sha = "abcdef0123456789abcdef0123456789abcdef01";
ASSERT_EQ(cbm_store_coverage_replace_ex(s, "coverage-sha", &row, 1, &new_meta),
CBM_STORE_OK);
got = (cbm_coverage_meta_t){0};
ASSERT_EQ(cbm_store_coverage_meta_get(s, "coverage-sha", &got), CBM_STORE_OK);
ASSERT_STR_EQ(got.indexed_checkout_sha, "abcdef0123456789abcdef0123456789abcdef01");
ASSERT_STR_EQ(got.generation, "gen-2");
cbm_store_coverage_meta_clear(&got);
/* Rollback: a failed replace must retain the prior identity + generation. */
ASSERT_EQ(cbm_store_exec(s, "CREATE TRIGGER fail_sha_missed_insert BEFORE INSERT ON nodes "
"WHEN NEW.project = 'coverage-sha::missed' "
"BEGIN SELECT RAISE(ABORT, 'forced sha shadow failure'); END;"),
CBM_STORE_OK);
cbm_coverage_meta_t failed_meta = new_meta;
failed_meta.generation = "gen-must-not-commit";
failed_meta.indexed_checkout_sha = "deadbeefdeadbeefdeadbeefdeadbeefdeadbeef";
cbm_coverage_row_t failed_row = row;
failed_row.detail = "changed-to-force-shadow-rebuild";
ASSERT_EQ(cbm_store_coverage_replace_ex(s, "coverage-sha", &failed_row, 1, &failed_meta),
CBM_STORE_ERR);
got = (cbm_coverage_meta_t){0};
ASSERT_EQ(cbm_store_coverage_meta_get(s, "coverage-sha", &got), CBM_STORE_OK);
ASSERT_STR_EQ(got.generation, "gen-2");
ASSERT_STR_EQ(got.indexed_checkout_sha, "abcdef0123456789abcdef0123456789abcdef01");
cbm_store_coverage_meta_clear(&got);
cbm_store_close(s);
PASS();
}
SUITE(store_nodes) {
RUN_TEST(store_qn_suffix_is_literal);
RUN_TEST(store_qn_suffix_is_unbounded);
@@ -2716,6 +2785,7 @@ SUITE(store_nodes) {
RUN_TEST(store_coverage_replace_rejects_invalid_row_arguments);
RUN_TEST(store_coverage_replace_rolls_back_when_shadow_rebuild_fails);
RUN_TEST(store_coverage_shadow_excludes_unresolved_calls);
RUN_TEST(store_coverage_meta_indexed_checkout_sha_roundtrip_and_rollback);
RUN_TEST(sql_label_allowlists_match_cbm_label_is_type_like);
RUN_TEST(sql_relation_labels_match_cbm_label_is_relation);
RUN_TEST(store_open_memory);