causoryn 0.0.0-stage → 0.2.0
This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
- package/.claude-plugin/plugin.json +36 -0
- package/.codex-plugin/mcp.json +19 -0
- package/.codex-plugin/plugin.json +38 -0
- package/.zcode-plugin/plugin.json +42 -0
- package/LICENSE +21 -0
- package/README.md +171 -2
- package/THIRD-PARTY-NOTICES.md +443 -0
- package/dist/bundle-manifest.json +39 -0
- package/dist/cli.d.ts +3 -0
- package/dist/cli.js +253 -0
- package/dist/doctor.d.ts +13 -0
- package/dist/doctor.js +507 -0
- package/dist/index.d.ts +10 -0
- package/dist/index.js +10 -0
- package/dist/mcp-server.mjs +288477 -0
- package/dist/mcp-server.mjs.LEGAL.txt +17 -0
- package/dist/node_modules/better-sqlite3/LICENSE +21 -0
- package/dist/node_modules/better-sqlite3/lib/binding.js +62 -0
- package/dist/node_modules/better-sqlite3/lib/darwin-arm64.js +3 -0
- package/dist/node_modules/better-sqlite3/lib/darwin-x64.js +3 -0
- package/dist/node_modules/better-sqlite3/lib/database.js +109 -0
- package/dist/node_modules/better-sqlite3/lib/index.js +3 -0
- package/dist/node_modules/better-sqlite3/lib/linux-arm64.js +3 -0
- package/dist/node_modules/better-sqlite3/lib/linux-x64.js +3 -0
- package/dist/node_modules/better-sqlite3/lib/linuxmusl-arm64.js +4 -0
- package/dist/node_modules/better-sqlite3/lib/linuxmusl-x64.js +4 -0
- package/dist/node_modules/better-sqlite3/lib/methods/aggregate.js +43 -0
- package/dist/node_modules/better-sqlite3/lib/methods/backup.js +67 -0
- package/dist/node_modules/better-sqlite3/lib/methods/explain.js +9 -0
- package/dist/node_modules/better-sqlite3/lib/methods/function.js +31 -0
- package/dist/node_modules/better-sqlite3/lib/methods/inspect.js +7 -0
- package/dist/node_modules/better-sqlite3/lib/methods/pragma.js +12 -0
- package/dist/node_modules/better-sqlite3/lib/methods/serialize.js +16 -0
- package/dist/node_modules/better-sqlite3/lib/methods/table.js +195 -0
- package/dist/node_modules/better-sqlite3/lib/methods/transaction.js +78 -0
- package/dist/node_modules/better-sqlite3/lib/methods/wrappers.js +54 -0
- package/dist/node_modules/better-sqlite3/lib/sqlite-error.js +25 -0
- package/dist/node_modules/better-sqlite3/lib/util.js +12 -0
- package/dist/node_modules/better-sqlite3/lib/win32-arm64.js +3 -0
- package/dist/node_modules/better-sqlite3/lib/win32-x64.js +3 -0
- package/dist/node_modules/better-sqlite3/package.json +67 -0
- package/dist/node_modules/better-sqlite3/prebuilds/darwin-arm64.node +0 -0
- package/dist/node_modules/better-sqlite3/prebuilds/darwin-x64.node +0 -0
- package/dist/node_modules/better-sqlite3/prebuilds/linux-arm64.node +0 -0
- package/dist/node_modules/better-sqlite3/prebuilds/linux-x64.node +0 -0
- package/dist/node_modules/better-sqlite3/prebuilds/linuxmusl-arm64.node +0 -0
- package/dist/node_modules/better-sqlite3/prebuilds/linuxmusl-x64.node +0 -0
- package/dist/node_modules/better-sqlite3/prebuilds/win32-arm64.node +0 -0
- package/dist/node_modules/better-sqlite3/prebuilds/win32-x64.node +0 -0
- package/dist/runtime-stage.d.ts +8 -0
- package/dist/runtime-stage.js +159 -0
- package/dist/setup.d.ts +15 -0
- package/dist/setup.js +735 -0
- package/dist/toml-patch.d.ts +10 -0
- package/dist/toml-patch.js +587 -0
- package/dist/types.d.ts +144 -0
- package/dist/types.js +35 -0
- package/dist/typescript-lib/lib.d.ts +22 -0
- package/dist/typescript-lib/lib.decorators.d.ts +384 -0
- package/dist/typescript-lib/lib.decorators.legacy.d.ts +22 -0
- package/dist/typescript-lib/lib.dom.asynciterable.d.ts +41 -0
- package/dist/typescript-lib/lib.dom.d.ts +39429 -0
- package/dist/typescript-lib/lib.dom.iterable.d.ts +571 -0
- package/dist/typescript-lib/lib.es2015.collection.d.ts +147 -0
- package/dist/typescript-lib/lib.es2015.core.d.ts +597 -0
- package/dist/typescript-lib/lib.es2015.d.ts +28 -0
- package/dist/typescript-lib/lib.es2015.generator.d.ts +77 -0
- package/dist/typescript-lib/lib.es2015.iterable.d.ts +605 -0
- package/dist/typescript-lib/lib.es2015.promise.d.ts +81 -0
- package/dist/typescript-lib/lib.es2015.proxy.d.ts +128 -0
- package/dist/typescript-lib/lib.es2015.reflect.d.ts +144 -0
- package/dist/typescript-lib/lib.es2015.symbol.d.ts +46 -0
- package/dist/typescript-lib/lib.es2015.symbol.wellknown.d.ts +326 -0
- package/dist/typescript-lib/lib.es2016.array.include.d.ts +116 -0
- package/dist/typescript-lib/lib.es2016.d.ts +21 -0
- package/dist/typescript-lib/lib.es2016.full.d.ts +23 -0
- package/dist/typescript-lib/lib.es2016.intl.d.ts +31 -0
- package/dist/typescript-lib/lib.es2017.arraybuffer.d.ts +21 -0
- package/dist/typescript-lib/lib.es2017.d.ts +26 -0
- package/dist/typescript-lib/lib.es2017.date.d.ts +31 -0
- package/dist/typescript-lib/lib.es2017.full.d.ts +23 -0
- package/dist/typescript-lib/lib.es2017.intl.d.ts +44 -0
- package/dist/typescript-lib/lib.es2017.object.d.ts +49 -0
- package/dist/typescript-lib/lib.es2017.sharedmemory.d.ts +135 -0
- package/dist/typescript-lib/lib.es2017.string.d.ts +45 -0
- package/dist/typescript-lib/lib.es2017.typedarrays.d.ts +53 -0
- package/dist/typescript-lib/lib.es2018.asyncgenerator.d.ts +77 -0
- package/dist/typescript-lib/lib.es2018.asynciterable.d.ts +53 -0
- package/dist/typescript-lib/lib.es2018.d.ts +24 -0
- package/dist/typescript-lib/lib.es2018.full.d.ts +24 -0
- package/dist/typescript-lib/lib.es2018.intl.d.ts +83 -0
- package/dist/typescript-lib/lib.es2018.promise.d.ts +30 -0
- package/dist/typescript-lib/lib.es2018.regexp.d.ts +37 -0
- package/dist/typescript-lib/lib.es2019.array.d.ts +79 -0
- package/dist/typescript-lib/lib.es2019.d.ts +24 -0
- package/dist/typescript-lib/lib.es2019.full.d.ts +24 -0
- package/dist/typescript-lib/lib.es2019.intl.d.ts +23 -0
- package/dist/typescript-lib/lib.es2019.object.d.ts +33 -0
- package/dist/typescript-lib/lib.es2019.string.d.ts +37 -0
- package/dist/typescript-lib/lib.es2019.symbol.d.ts +24 -0
- package/dist/typescript-lib/lib.es2020.bigint.d.ts +765 -0
- package/dist/typescript-lib/lib.es2020.d.ts +27 -0
- package/dist/typescript-lib/lib.es2020.date.d.ts +42 -0
- package/dist/typescript-lib/lib.es2020.full.d.ts +24 -0
- package/dist/typescript-lib/lib.es2020.intl.d.ts +474 -0
- package/dist/typescript-lib/lib.es2020.number.d.ts +28 -0
- package/dist/typescript-lib/lib.es2020.promise.d.ts +47 -0
- package/dist/typescript-lib/lib.es2020.sharedmemory.d.ts +99 -0
- package/dist/typescript-lib/lib.es2020.string.d.ts +44 -0
- package/dist/typescript-lib/lib.es2020.symbol.wellknown.d.ts +41 -0
- package/dist/typescript-lib/lib.es2021.d.ts +23 -0
- package/dist/typescript-lib/lib.es2021.full.d.ts +24 -0
- package/dist/typescript-lib/lib.es2021.intl.d.ts +166 -0
- package/dist/typescript-lib/lib.es2021.promise.d.ts +48 -0
- package/dist/typescript-lib/lib.es2021.string.d.ts +33 -0
- package/dist/typescript-lib/lib.es2021.weakref.d.ts +78 -0
- package/dist/typescript-lib/lib.es2022.array.d.ts +121 -0
- package/dist/typescript-lib/lib.es2022.d.ts +25 -0
- package/dist/typescript-lib/lib.es2022.error.d.ts +75 -0
- package/dist/typescript-lib/lib.es2022.full.d.ts +24 -0
- package/dist/typescript-lib/lib.es2022.intl.d.ts +145 -0
- package/dist/typescript-lib/lib.es2022.object.d.ts +26 -0
- package/dist/typescript-lib/lib.es2022.regexp.d.ts +39 -0
- package/dist/typescript-lib/lib.es2022.string.d.ts +25 -0
- package/dist/typescript-lib/lib.es2023.array.d.ts +924 -0
- package/dist/typescript-lib/lib.es2023.collection.d.ts +21 -0
- package/dist/typescript-lib/lib.es2023.d.ts +22 -0
- package/dist/typescript-lib/lib.es2023.full.d.ts +24 -0
- package/dist/typescript-lib/lib.es2023.intl.d.ts +56 -0
- package/dist/typescript-lib/lib.es2024.arraybuffer.d.ts +65 -0
- package/dist/typescript-lib/lib.es2024.collection.d.ts +29 -0
- package/dist/typescript-lib/lib.es2024.d.ts +26 -0
- package/dist/typescript-lib/lib.es2024.full.d.ts +24 -0
- package/dist/typescript-lib/lib.es2024.object.d.ts +29 -0
- package/dist/typescript-lib/lib.es2024.promise.d.ts +35 -0
- package/dist/typescript-lib/lib.es2024.regexp.d.ts +25 -0
- package/dist/typescript-lib/lib.es2024.sharedmemory.d.ts +68 -0
- package/dist/typescript-lib/lib.es2024.string.d.ts +29 -0
- package/dist/typescript-lib/lib.es5.d.ts +4601 -0
- package/dist/typescript-lib/lib.es6.d.ts +23 -0
- package/dist/typescript-lib/lib.esnext.array.d.ts +35 -0
- package/dist/typescript-lib/lib.esnext.collection.d.ts +96 -0
- package/dist/typescript-lib/lib.esnext.d.ts +29 -0
- package/dist/typescript-lib/lib.esnext.decorators.d.ts +28 -0
- package/dist/typescript-lib/lib.esnext.disposable.d.ts +193 -0
- package/dist/typescript-lib/lib.esnext.error.d.ts +24 -0
- package/dist/typescript-lib/lib.esnext.float16.d.ts +445 -0
- package/dist/typescript-lib/lib.esnext.full.d.ts +24 -0
- package/dist/typescript-lib/lib.esnext.intl.d.ts +21 -0
- package/dist/typescript-lib/lib.esnext.iterator.d.ts +148 -0
- package/dist/typescript-lib/lib.esnext.promise.d.ts +34 -0
- package/dist/typescript-lib/lib.esnext.sharedmemory.d.ts +25 -0
- package/dist/typescript-lib/lib.scripthost.d.ts +322 -0
- package/dist/typescript-lib/lib.webworker.asynciterable.d.ts +41 -0
- package/dist/typescript-lib/lib.webworker.d.ts +13150 -0
- package/dist/typescript-lib/lib.webworker.importscripts.d.ts +23 -0
- package/dist/typescript-lib/lib.webworker.iterable.d.ts +340 -0
- package/licenses/Apache-2.0.txt +55 -0
- package/licenses/TypeScript-ThirdPartyNoticeText.txt +193 -0
- package/licenses/better-sqlite3-LICENSE.txt +21 -0
- package/mcp_config.json +16 -0
- package/native/go-worker/PROTOCOL.md +316 -0
- package/native/go-worker/cmd/worker/main.go +440 -0
- package/native/go-worker/go.mod +3 -0
- package/native/go-worker/internal/analyze/analyze.go +820 -0
- package/native/go-worker/internal/analyze/model.go +182 -0
- package/native/go-worker/internal/analyze/routes.go +181 -0
- package/native/python-worker/PROTOCOL.md +342 -0
- package/native/python-worker/worker.py +1190 -0
- package/native/roslyn-worker/Causoryn.RoslynWorker.csproj +40 -0
- package/native/roslyn-worker/Causoryn.RoslynWorker.deps.json +59 -0
- package/native/roslyn-worker/Causoryn.RoslynWorker.dll +0 -0
- package/native/roslyn-worker/Causoryn.RoslynWorker.runtimeconfig.json +13 -0
- package/native/roslyn-worker/Microsoft.CodeAnalysis.CSharp.dll +0 -0
- package/native/roslyn-worker/Microsoft.CodeAnalysis.dll +0 -0
- package/native/roslyn-worker/PROTOCOL.md +285 -0
- package/native/roslyn-worker/Program.cs +249 -0
- package/native/roslyn-worker/Protocol.cs +397 -0
- package/native/roslyn-worker/ReferenceResolver.cs +235 -0
- package/native/roslyn-worker/WorkerAnalyzer.cs +1669 -0
- package/native/roslyn-worker/packages.lock.json +30 -0
- package/native/rust-worker/Cargo.lock +107 -0
- package/native/rust-worker/Cargo.toml +23 -0
- package/native/rust-worker/PROTOCOL.md +294 -0
- package/native/rust-worker/src/analyzer.rs +1209 -0
- package/native/rust-worker/src/main.rs +127 -0
- package/native/rust-worker/src/protocol.rs +284 -0
- package/native/rust-worker/src/sha256.rs +136 -0
- package/package.json +71 -4
- package/plugin.json +17 -0
- package/scripts/causoryn.mjs +40 -0
- package/scripts/lib/node-version-guard.mjs +24 -0
- package/scripts/plugin-mcp-launcher.mjs +111 -0
- package/skills/causoryn/SKILL.md +53 -0
- package/skills/map-system/SKILL.md +69 -0
- package/skills/preflight-change/SKILL.md +38 -0
- package/skills/verify-change/SKILL.md +31 -0
|
@@ -0,0 +1,1190 @@
|
|
|
1
|
+
#!/usr/bin/env python3
|
|
2
|
+
# -*- coding: utf-8 -*-
|
|
3
|
+
"""Causoryn Python sidecar worker — protokol v1 (native/python-worker/PROTOCOL.md).
|
|
4
|
+
|
|
5
|
+
LLM çalıştırmayan, yerel ve deterministik Python çözümleyicisi. Yalnızca
|
|
6
|
+
Python stdlib kullanır (ast + hashlib + json + sys — sıfır dış bağımlılık).
|
|
7
|
+
Süreç stdin'den satır satır istek okur, her isteğe tek satır JSON yanıt
|
|
8
|
+
döner ve analiz boyunca kullanıcı workspace'ine HİÇBİR YAZMA yapmaz
|
|
9
|
+
(ADR-008 deseni; roslyn-worker ile aynı süreç sözleşmesi).
|
|
10
|
+
|
|
11
|
+
Desen kaynağı: native/roslyn-worker (Program.cs/WorkerAnalyzer.cs) ve
|
|
12
|
+
adapters/csharp-roslyn — stdin/stdout satır-bazlı JSON, PROTOCOL.md,
|
|
13
|
+
graceful fallback. TŞ v2.1 §7: "Python FastAPI/Django — Python AST +
|
|
14
|
+
framework rules; L1/L2, seçili L3".
|
|
15
|
+
|
|
16
|
+
Kırmızı çizgiler (proje sözleşmesi):
|
|
17
|
+
- stdout'ta YALNIZCA protokol satırları taşınır; loglar stderr'e yazılır
|
|
18
|
+
("[python-worker] " öneki ile).
|
|
19
|
+
- Spawn güvenliği: bu script yalnızca SABİT yolla çağrılır; istek içeriği
|
|
20
|
+
yalnızca stdin üzerinden taşınır; hiçbir girdi komuta interpole edilmez.
|
|
21
|
+
- Determinizm: aynı files girdisi → birebir aynı yanıt satırı (saat okunmaz,
|
|
22
|
+
çıktı kanonik anahtarla sıralanır).
|
|
23
|
+
|
|
24
|
+
Çözümleme dürüstlük kuralları (TŞ §8 resolution):
|
|
25
|
+
- verified : hedef AYNI modülde tanımlı (AST isim bağlamı; modül düzeyi
|
|
26
|
+
ad, self.<m>, AynıModülSınıfı.<m>) ya da dekoratör handler
|
|
27
|
+
ilişkisi (dekoratör handler'ın kendisine sözdizimsel bağlıdır).
|
|
28
|
+
- heuristic : hedef IMPORT EDİLEN modül sembolü (tam type inference YOK —
|
|
29
|
+
Python ad bağlamı dinamiktir; kenar ambiguity ile işaretli).
|
|
30
|
+
- unresolved : çözülemeyen çağrılar → açık UnknownExternal node; uydurma
|
|
31
|
+
hedef/kenar üretilmez.
|
|
32
|
+
|
|
33
|
+
Çıkış kodları: 0 = normal EOF; 1 = stdio kablosu kırıldı (BrokenPipeError).
|
|
34
|
+
"""
|
|
35
|
+
|
|
36
|
+
from __future__ import annotations
|
|
37
|
+
|
|
38
|
+
import ast
|
|
39
|
+
import hashlib
|
|
40
|
+
import json
|
|
41
|
+
import re
|
|
42
|
+
import sys
|
|
43
|
+
from typing import Any, Dict, List, Optional, Tuple
|
|
44
|
+
|
|
45
|
+
PROTOCOL_VERSION = "1"
|
|
46
|
+
ANALYZER_ID = "python-worker"
|
|
47
|
+
ANALYZER_VERSION = "0.1.0"
|
|
48
|
+
|
|
49
|
+
# Kaynak sınırları — roslyn-worker Protocol.cs ile aynı bütçeler (TŞ §9;
|
|
50
|
+
# K-010: yalnızca boyut limitleri). Sabittir, istekte yapılandırılamaz.
|
|
51
|
+
MAX_REQUEST_LINE_BYTES = 64 * 1024 * 1024
|
|
52
|
+
MAX_FILE_COUNT = 5000
|
|
53
|
+
MAX_FILE_CONTENT_BYTES = 2_000_000
|
|
54
|
+
MAX_RESPONSE_NODES = 250_000
|
|
55
|
+
|
|
56
|
+
# AST gezinme derinlik savunması (roslyn MAX_TRAVERSAL_DEPTH karşılığı).
|
|
57
|
+
# NOT (takım denetimi bulgusu): birincil savunma CPython parser'ının
|
|
58
|
+
# YAPISAL SINIRLARI'dır — çok derin iç içe yapılar ast.parse aşamasında
|
|
59
|
+
# SyntaxError ('too many levels of indentation' / 'too many nested
|
|
60
|
+
# parentheses') ile reddedilir ve dosya başına partial tanısı yazılır
|
|
61
|
+
# (tests/python-worker.test.ts 'aşırı derin iç içe yapı' testi). Bu sayaç
|
|
62
|
+
# yalnızca parse edilebilir derinlik aralığında İKİNCİL katmandır ve tipik
|
|
63
|
+
# koşumda tetiklenmez. SÜREÇ YAŞAMLILIĞININ GERÇEK MEKANİZMASI (takım
|
|
64
|
+
# denetimi tur-2): bildirim/çağrı gezinmesi REKÜRSİFTİR (_declare/
|
|
65
|
+
# _walk_calls) — beklenmedik derinlik RecursionError üretebilir; süreç
|
|
66
|
+
# bununla ölmez çünkü handle_line'ın analiz gövdesini saran except
|
|
67
|
+
# Exception savunması her istisnayı istek-başına hata/INTERNAL_ERROR
|
|
68
|
+
# yanıtına çevirir ve döngüyü ayakta tutar (json.loads derin JSON
|
|
69
|
+
# RecursionError'u da ayrıca yakalanır — 'derin iç içe JSON' testi).
|
|
70
|
+
MAX_AST_DEPTH = 1000
|
|
71
|
+
|
|
72
|
+
# TŞ §8 katalogları — worker liste dışı tür üretemez (çıkışta sert doğrulama).
|
|
73
|
+
NODE_KINDS = frozenset(
|
|
74
|
+
{
|
|
75
|
+
"Workspace", "Repository", "Project", "Module", "Package", "File",
|
|
76
|
+
"Namespace", "Class", "Interface", "Type", "Function", "Method",
|
|
77
|
+
"Endpoint", "Handler", "Event", "Topic", "Queue", "Database", "Table",
|
|
78
|
+
"Column", "ApiContract", "EventContract", "SchemaContract",
|
|
79
|
+
"ContractVersion", "Test", "Config", "UnknownExternal",
|
|
80
|
+
}
|
|
81
|
+
)
|
|
82
|
+
EDGE_KINDS = frozenset(
|
|
83
|
+
{
|
|
84
|
+
"CONTAINS", "IMPORTS", "DECLARES", "CALLS", "REFERENCES", "IMPLEMENTS",
|
|
85
|
+
"INHERITS", "INJECTS", "ROUTES_TO", "READS", "WRITES", "PUBLISHES",
|
|
86
|
+
"SUBSCRIBES", "HANDLES", "PRODUCES_CONTRACT", "CONSUMES_CONTRACT",
|
|
87
|
+
"VALIDATES", "TESTS", "DEPENDS_ON", "CONFIGURES",
|
|
88
|
+
}
|
|
89
|
+
)
|
|
90
|
+
RESOLUTIONS = frozenset({"verified", "heuristic", "unresolved"})
|
|
91
|
+
EVIDENCE_KINDS = frozenset(
|
|
92
|
+
{
|
|
93
|
+
"ast-span", "semantic-symbol", "route-attribute", "di-registration",
|
|
94
|
+
"openapi-spec", "asyncapi-spec", "migration-schema", "config-manifest",
|
|
95
|
+
"git-diff", "test-assertion", "runtime-trace",
|
|
96
|
+
}
|
|
97
|
+
)
|
|
98
|
+
|
|
99
|
+
# Framework route kuralları (TŞ §7: Python AST + framework rules, seçili L3).
|
|
100
|
+
# Taşıyıcı adına (app/router/api/bp...) kısıt KOYULMAZ: HTTP fiili / api_route
|
|
101
|
+
# / route adlı dekoratör kullanımında fiilen yalnızca rota kaydı yapılır;
|
|
102
|
+
# taşıyıcı semantik olarak çözümlenmediği için Endpoint, dekoratörün LİTERAL
|
|
103
|
+
# argümanlarından türetilir (TŞ §8: kanıt route-attribute).
|
|
104
|
+
HTTP_VERB_DECORATORS = frozenset(
|
|
105
|
+
{"get", "post", "put", "patch", "delete", "head", "options", "trace"}
|
|
106
|
+
)
|
|
107
|
+
ROUTE_NAMED_DECORATORS = frozenset({"route", "api_route"})
|
|
108
|
+
|
|
109
|
+
UNSUPPORTED_CONSTRUCTS = [
|
|
110
|
+
"monkey-patching",
|
|
111
|
+
"runtime-dependency-injection",
|
|
112
|
+
"dynamic-import (importlib/__import__)",
|
|
113
|
+
"local-variable-type-inference",
|
|
114
|
+
"module-level-calls (caller'sız)",
|
|
115
|
+
"decorator-arg-non-literal-path",
|
|
116
|
+
"function-level-imports (yalnızca modül düzeyi import tablosu)",
|
|
117
|
+
]
|
|
118
|
+
|
|
119
|
+
_DRIVE_LETTER = re.compile(r"^[A-Za-z]:")
|
|
120
|
+
|
|
121
|
+
|
|
122
|
+
def log(message: str) -> None:
|
|
123
|
+
"""Loglar YALNIZCA stderr'e yazılır (kırmızı çizgi 4)."""
|
|
124
|
+
print(f"[python-worker] {message}", file=sys.stderr, flush=True)
|
|
125
|
+
|
|
126
|
+
|
|
127
|
+
def _force_utf8_stderr() -> None:
|
|
128
|
+
"""Log kanalını UTF-8'e sabitler (takım denetimi bulgusu).
|
|
129
|
+
|
|
130
|
+
Piped stderr, PYTHONIOENCODING setli değilken Windows'ta locale kod
|
|
131
|
+
sayfasına (ör. cp1254) düşer; Türkçe log metni bozulur ve adapter
|
|
132
|
+
stderr'i UTF-8 okuyup fallback warnings'ine bozuk gömer. stdout protokol
|
|
133
|
+
kanalı zaten binary buffer ile UTF-8'dir; bu düzeltme yalnızca log
|
|
134
|
+
kanalı içindir. Adapter tarafında da spawn env'inde PYTHONIOENCODING
|
|
135
|
+
sabitlenir (çifte savunma; parent env'e bağımlılık yoktur).
|
|
136
|
+
"""
|
|
137
|
+
reconfigure = getattr(sys.stderr, "reconfigure", None)
|
|
138
|
+
if callable(reconfigure):
|
|
139
|
+
try:
|
|
140
|
+
reconfigure(encoding="utf-8")
|
|
141
|
+
except (OSError, ValueError):
|
|
142
|
+
pass # reconfigure desteklenmiyorsa binary stdout disiplini yine sağlamdır
|
|
143
|
+
|
|
144
|
+
|
|
145
|
+
_force_utf8_stderr()
|
|
146
|
+
|
|
147
|
+
|
|
148
|
+
def canonical(value: Any) -> str:
|
|
149
|
+
"""Kanonik JSON dizesi — deterministik sıralama/dedupe anahtarı."""
|
|
150
|
+
return json.dumps(value, ensure_ascii=False, sort_keys=True, separators=(",", ":"))
|
|
151
|
+
|
|
152
|
+
|
|
153
|
+
def sha256_hex(content: str) -> str:
|
|
154
|
+
"""UTF-8 SHA-256 — domain sha256Hex(utf8Encode(content)) ile bit-bit aynı."""
|
|
155
|
+
return hashlib.sha256(content.encode("utf-8")).hexdigest()
|
|
156
|
+
|
|
157
|
+
|
|
158
|
+
def module_name_from_path(relative_path: str) -> str:
|
|
159
|
+
"""Workspace-relative POSIX yol → Python modül adı.
|
|
160
|
+
|
|
161
|
+
"app.py" → "app"; "services/orders_service.py" → "services.orders_service";
|
|
162
|
+
"pkg/__init__.py" → "pkg". Türetilemezse (kök __init__.py) relative_path.
|
|
163
|
+
"""
|
|
164
|
+
without_ext = relative_path[:-3] if relative_path.endswith(".py") else relative_path
|
|
165
|
+
parts = [part for part in without_ext.split("/") if part]
|
|
166
|
+
if parts and parts[-1] == "__init__":
|
|
167
|
+
parts = parts[:-1]
|
|
168
|
+
return ".".join(parts) if parts else relative_path
|
|
169
|
+
|
|
170
|
+
|
|
171
|
+
def error_response(request_id: Any, code: str, message: str) -> Dict[str, Any]:
|
|
172
|
+
return {
|
|
173
|
+
"id": request_id,
|
|
174
|
+
"protocolVersion": PROTOCOL_VERSION,
|
|
175
|
+
"status": "error",
|
|
176
|
+
"error": {"code": code, "message": message},
|
|
177
|
+
}
|
|
178
|
+
|
|
179
|
+
|
|
180
|
+
def describe_id(value: Any) -> str:
|
|
181
|
+
if value is None:
|
|
182
|
+
return "null"
|
|
183
|
+
return value if isinstance(value, str) else str(value)
|
|
184
|
+
|
|
185
|
+
|
|
186
|
+
# ---------------------------------------------------------------------------
|
|
187
|
+
# İstek doğrulama — kesin şema reddi (bilinmeyen alan INVALID_ARGUMENT)
|
|
188
|
+
# ---------------------------------------------------------------------------
|
|
189
|
+
|
|
190
|
+
_ALLOWED_TOP_LEVEL = frozenset({"id", "type", "protocolVersion", "files", "maxNodes"})
|
|
191
|
+
_ALLOWED_FILE_KEYS = frozenset({"path", "content"})
|
|
192
|
+
|
|
193
|
+
|
|
194
|
+
def valid_id(value: Any) -> bool:
|
|
195
|
+
"""id: string veya sayı (bool hariç — JSON true/false sayı değildir)."""
|
|
196
|
+
return isinstance(value, (str, int)) and not isinstance(value, bool)
|
|
197
|
+
|
|
198
|
+
|
|
199
|
+
def validate_relative_path(raw: Any) -> Tuple[Optional[str], Optional[str]]:
|
|
200
|
+
"""POSIX workspace-relative yol sözleşmesi. (path, hata_mesajı) döner."""
|
|
201
|
+
if not isinstance(raw, str) or len(raw) == 0:
|
|
202
|
+
return None, "files[].path boş olamaz"
|
|
203
|
+
if "\\" in raw:
|
|
204
|
+
return None, f"files[].path POSIX olmalı (backslash kabul edilmez): {raw}"
|
|
205
|
+
if raw.startswith("/"):
|
|
206
|
+
return None, f"files[].path mutlak yol kabul edilmez: {raw}"
|
|
207
|
+
if _DRIVE_LETTER.match(raw):
|
|
208
|
+
return None, f"files[].path sürücü harfli mutlak yol kabul edilmez: {raw}"
|
|
209
|
+
for segment in raw.split("/"):
|
|
210
|
+
if len(segment) == 0:
|
|
211
|
+
return None, f"files[].path boş segment içeriyor: {raw}"
|
|
212
|
+
if segment == ".":
|
|
213
|
+
return None, f"files[].path '.' segment içeriyor: {raw}"
|
|
214
|
+
if segment == "..":
|
|
215
|
+
return None, f"files[].path kök dışına çıkıyor ('..'): {raw}"
|
|
216
|
+
return raw, None
|
|
217
|
+
|
|
218
|
+
|
|
219
|
+
def validate_request(payload: Any) -> Tuple[Optional[Dict[str, Any]], Optional[Dict[str, Any]]]:
|
|
220
|
+
"""(istek, None) ya da (None, error_response) döner."""
|
|
221
|
+
if not isinstance(payload, dict):
|
|
222
|
+
return None, error_response(None, "INVALID_ARGUMENT", "istek bir JSON nesnesi olmalı")
|
|
223
|
+
|
|
224
|
+
raw_id = payload.get("id")
|
|
225
|
+
echoed_id: Any = raw_id if valid_id(raw_id) else None
|
|
226
|
+
|
|
227
|
+
unknown = sorted(set(payload.keys()) - _ALLOWED_TOP_LEVEL)
|
|
228
|
+
if unknown:
|
|
229
|
+
return None, error_response(
|
|
230
|
+
echoed_id,
|
|
231
|
+
"INVALID_ARGUMENT",
|
|
232
|
+
f"bilinmeyen istek alan(lar)ı: {', '.join(unknown)}",
|
|
233
|
+
)
|
|
234
|
+
|
|
235
|
+
if "id" not in payload or not valid_id(raw_id):
|
|
236
|
+
return None, error_response(None, "INVALID_ARGUMENT", "id string veya sayı olmalı (zorunlu)")
|
|
237
|
+
|
|
238
|
+
if payload.get("type") != "analyze":
|
|
239
|
+
return None, error_response(
|
|
240
|
+
echoed_id,
|
|
241
|
+
"INVALID_ARGUMENT",
|
|
242
|
+
f"type 'analyze' olmalı: {payload.get('type')!r}",
|
|
243
|
+
)
|
|
244
|
+
|
|
245
|
+
protocol_version = payload.get("protocolVersion")
|
|
246
|
+
if protocol_version is not None and protocol_version != PROTOCOL_VERSION:
|
|
247
|
+
return None, error_response(
|
|
248
|
+
echoed_id,
|
|
249
|
+
"INVALID_ARGUMENT",
|
|
250
|
+
f"desteklenmeyen protocolVersion: {protocol_version!r}",
|
|
251
|
+
)
|
|
252
|
+
|
|
253
|
+
max_nodes = payload.get("maxNodes")
|
|
254
|
+
if max_nodes is not None:
|
|
255
|
+
if isinstance(max_nodes, bool) or not isinstance(max_nodes, int):
|
|
256
|
+
return None, error_response(echoed_id, "INVALID_ARGUMENT", "maxNodes tam sayı olmalı")
|
|
257
|
+
if not (1 <= max_nodes <= MAX_RESPONSE_NODES):
|
|
258
|
+
return None, error_response(
|
|
259
|
+
echoed_id,
|
|
260
|
+
"INVALID_ARGUMENT",
|
|
261
|
+
f"maxNodes 1..{MAX_RESPONSE_NODES} aralığında olmalı: {max_nodes}",
|
|
262
|
+
)
|
|
263
|
+
|
|
264
|
+
files = payload.get("files")
|
|
265
|
+
if not isinstance(files, list) or len(files) == 0:
|
|
266
|
+
return None, error_response(echoed_id, "INVALID_ARGUMENT", "files boş olmayan bir dizi olmalı")
|
|
267
|
+
if len(files) > MAX_FILE_COUNT:
|
|
268
|
+
return None, error_response(
|
|
269
|
+
echoed_id,
|
|
270
|
+
"LIMIT_EXCEEDED",
|
|
271
|
+
f"dosya sayısı sınırı aşıldı: {len(files)} > {MAX_FILE_COUNT}",
|
|
272
|
+
)
|
|
273
|
+
|
|
274
|
+
seen_paths: set = set()
|
|
275
|
+
for index, item in enumerate(files):
|
|
276
|
+
if not isinstance(item, dict):
|
|
277
|
+
return None, error_response(
|
|
278
|
+
echoed_id, "INVALID_ARGUMENT", f"files[{index}] bir nesne olmalı"
|
|
279
|
+
)
|
|
280
|
+
unknown_file_keys = sorted(set(item.keys()) - _ALLOWED_FILE_KEYS)
|
|
281
|
+
if unknown_file_keys:
|
|
282
|
+
return None, error_response(
|
|
283
|
+
echoed_id,
|
|
284
|
+
"INVALID_ARGUMENT",
|
|
285
|
+
f"files[{index}] bilinmeyen alan içeriyor: {', '.join(unknown_file_keys)}",
|
|
286
|
+
)
|
|
287
|
+
path, path_error = validate_relative_path(item.get("path"))
|
|
288
|
+
if path_error is not None:
|
|
289
|
+
return None, error_response(echoed_id, "INVALID_ARGUMENT", path_error)
|
|
290
|
+
if path in seen_paths:
|
|
291
|
+
return None, error_response(
|
|
292
|
+
echoed_id, "INVALID_ARGUMENT", f"aynı kaynak yolu iki kez verildi: {path}"
|
|
293
|
+
)
|
|
294
|
+
seen_paths.add(path)
|
|
295
|
+
content = item.get("content")
|
|
296
|
+
if not isinstance(content, str):
|
|
297
|
+
return None, error_response(
|
|
298
|
+
echoed_id, "INVALID_ARGUMENT", f"files[{index}].content string olmalı"
|
|
299
|
+
)
|
|
300
|
+
content_bytes = len(content.encode("utf-8"))
|
|
301
|
+
if content_bytes > MAX_FILE_CONTENT_BYTES:
|
|
302
|
+
return None, error_response(
|
|
303
|
+
echoed_id,
|
|
304
|
+
"LIMIT_EXCEEDED",
|
|
305
|
+
f"dosya içeriği sınırı aşıldı: {path} ({content_bytes} > {MAX_FILE_CONTENT_BYTES} bayt)",
|
|
306
|
+
)
|
|
307
|
+
|
|
308
|
+
request: Dict[str, Any] = {
|
|
309
|
+
"id": raw_id,
|
|
310
|
+
"files": [{"path": item["path"], "content": item["content"]} for item in files],
|
|
311
|
+
}
|
|
312
|
+
if max_nodes is not None:
|
|
313
|
+
request["maxNodes"] = max_nodes
|
|
314
|
+
return request, None
|
|
315
|
+
|
|
316
|
+
|
|
317
|
+
# ---------------------------------------------------------------------------
|
|
318
|
+
# Analiz — bildirim, route ve çağrı çözümleme
|
|
319
|
+
# ---------------------------------------------------------------------------
|
|
320
|
+
|
|
321
|
+
class FileAnalyzer:
|
|
322
|
+
"""Tek dosyanın AST çözümlemesi; sonuçlar istek düzeyi toplayıcıya yazılır."""
|
|
323
|
+
|
|
324
|
+
def __init__(
|
|
325
|
+
self,
|
|
326
|
+
relative_path: str,
|
|
327
|
+
content: str,
|
|
328
|
+
tree: ast.AST,
|
|
329
|
+
collector: "RequestCollector",
|
|
330
|
+
) -> None:
|
|
331
|
+
self.path = relative_path
|
|
332
|
+
self.content = content
|
|
333
|
+
self.source_hash = sha256_hex(content)
|
|
334
|
+
self.module = module_name_from_path(relative_path)
|
|
335
|
+
self.tree = tree
|
|
336
|
+
self.collector = collector
|
|
337
|
+
# Modül düzeyi ad tablosu: ad → (node_kind, qualified_name)
|
|
338
|
+
self.module_symbols: Dict[str, Tuple[str, str]] = {}
|
|
339
|
+
# Sınıf üye tablosu: class_qualified_name → {üye adı → (kind, qn)}
|
|
340
|
+
self.class_members: Dict[str, Dict[str, Tuple[str, str]]] = {}
|
|
341
|
+
# import bağlama tablosu: yerel ad → ("module", dotted) | ("symbol", dotted, ad)
|
|
342
|
+
self.import_bindings: Dict[str, Tuple[str, ...]] = {}
|
|
343
|
+
# Çağrı sahipleri: (ast node, kind, qn, class_qn)
|
|
344
|
+
self.callables: List[Tuple[ast.stmt, str, str, Optional[str]]] = []
|
|
345
|
+
self.depth_exceeded = False
|
|
346
|
+
|
|
347
|
+
# -- yardımcılar ----------------------------------------------------------
|
|
348
|
+
|
|
349
|
+
def file_ref(self) -> Dict[str, Any]:
|
|
350
|
+
return {"kind": "File", "qualifiedName": self.path, "relativePath": self.path}
|
|
351
|
+
|
|
352
|
+
def ref(self, kind: str, qualified_name: str) -> Dict[str, Any]:
|
|
353
|
+
return {"kind": kind, "qualifiedName": qualified_name, "relativePath": self.path}
|
|
354
|
+
|
|
355
|
+
def external_ref(self, qualified_name: str) -> Dict[str, Any]:
|
|
356
|
+
"""Dış/çözümsüz hedef: dosya taşımaz (analiz seti dışı sembol)."""
|
|
357
|
+
return {"kind": "UnknownExternal", "qualifiedName": qualified_name}
|
|
358
|
+
|
|
359
|
+
def span(self, start_line: Optional[int], end_line: Optional[int]) -> Dict[str, Any]:
|
|
360
|
+
start = start_line if isinstance(start_line, int) and start_line > 0 else 0
|
|
361
|
+
end = end_line if isinstance(end_line, int) and end_line >= start else start
|
|
362
|
+
return {
|
|
363
|
+
"relativePath": self.path,
|
|
364
|
+
"startLine": start,
|
|
365
|
+
"endLine": end,
|
|
366
|
+
"sourceHash": self.source_hash,
|
|
367
|
+
}
|
|
368
|
+
|
|
369
|
+
def evidence(self, kind: str, node: ast.AST, rationale: str) -> Dict[str, Any]:
|
|
370
|
+
return {
|
|
371
|
+
"kind": kind,
|
|
372
|
+
"span": self.span(getattr(node, "lineno", None), getattr(node, "end_lineno", None)),
|
|
373
|
+
"analyzerId": ANALYZER_ID,
|
|
374
|
+
"analyzerVersion": ANALYZER_VERSION,
|
|
375
|
+
"rationale": rationale,
|
|
376
|
+
}
|
|
377
|
+
|
|
378
|
+
# -- geçiş 1: bildirimler ---------------------------------------------------
|
|
379
|
+
|
|
380
|
+
def analyze(self) -> None:
|
|
381
|
+
self.collector.add_file_node(self.path, self.source_hash)
|
|
382
|
+
self._register_imports(self.tree.body)
|
|
383
|
+
for statement in self.tree.body:
|
|
384
|
+
self._declare(statement, prefix=self.module, parent=self.file_ref(),
|
|
385
|
+
in_class=False, class_qn=None, depth=1)
|
|
386
|
+
# Çok dosyalı setlerde import çözümlemesi için semboller global kayda yazılır.
|
|
387
|
+
for kind, qualified in self.module_symbols.values():
|
|
388
|
+
self.collector.register_symbol(qualified, kind, self.path)
|
|
389
|
+
for class_qn, members in self.class_members.items():
|
|
390
|
+
self.collector.register_class_members(
|
|
391
|
+
class_qn,
|
|
392
|
+
{name: (member_kind, member_qn, self.path)
|
|
393
|
+
for name, (member_kind, member_qn) in members.items()},
|
|
394
|
+
)
|
|
395
|
+
|
|
396
|
+
def _declare(
|
|
397
|
+
self,
|
|
398
|
+
statement: ast.stmt,
|
|
399
|
+
prefix: str,
|
|
400
|
+
parent: Dict[str, Any],
|
|
401
|
+
in_class: bool,
|
|
402
|
+
class_qn: Optional[str],
|
|
403
|
+
depth: int,
|
|
404
|
+
) -> None:
|
|
405
|
+
if depth > MAX_AST_DEPTH:
|
|
406
|
+
self.depth_exceeded = True
|
|
407
|
+
return
|
|
408
|
+
|
|
409
|
+
if isinstance(statement, (ast.FunctionDef, ast.AsyncFunctionDef)):
|
|
410
|
+
name = statement.name
|
|
411
|
+
kind = "Method" if in_class else "Function"
|
|
412
|
+
qualified = f"{prefix}.{name}"
|
|
413
|
+
self.collector.add_node(kind, qualified, self.path)
|
|
414
|
+
self.collector.add_contains(
|
|
415
|
+
parent, self.ref(kind, qualified),
|
|
416
|
+
self.evidence(
|
|
417
|
+
"ast-span",
|
|
418
|
+
statement,
|
|
419
|
+
f"CONTAINS: {self.path} dosyasındaki {qualified} {kind.lower()} "
|
|
420
|
+
"bildirimi AST span kanıtıyla eşlendi.",
|
|
421
|
+
),
|
|
422
|
+
)
|
|
423
|
+
if prefix == self.module:
|
|
424
|
+
self.module_symbols[name] = (kind, qualified)
|
|
425
|
+
if in_class and class_qn is not None:
|
|
426
|
+
self.class_members.setdefault(class_qn, {})[name] = (kind, qualified)
|
|
427
|
+
self.callables.append((statement, kind, qualified, class_qn))
|
|
428
|
+
self._collect_routes(statement, qualified, kind)
|
|
429
|
+
# Fonksiyon gövdesindeki iç içe bildirimler ayrı kayıt olur
|
|
430
|
+
# (sınıf üyesi DEĞİLDİR — in_class=False).
|
|
431
|
+
for child in statement.body:
|
|
432
|
+
self._declare(child, prefix=qualified, parent=self.ref(kind, qualified),
|
|
433
|
+
in_class=False, class_qn=None, depth=depth + 1)
|
|
434
|
+
return
|
|
435
|
+
|
|
436
|
+
if isinstance(statement, ast.ClassDef):
|
|
437
|
+
name = statement.name
|
|
438
|
+
qualified = f"{prefix}.{name}"
|
|
439
|
+
self.collector.add_node("Class", qualified, self.path)
|
|
440
|
+
self.collector.add_contains(
|
|
441
|
+
parent, self.ref("Class", qualified),
|
|
442
|
+
self.evidence(
|
|
443
|
+
"ast-span",
|
|
444
|
+
statement,
|
|
445
|
+
f"CONTAINS: {self.path} dosyasındaki {qualified} class bildirimi "
|
|
446
|
+
"AST span kanıtıyla eşlendi.",
|
|
447
|
+
),
|
|
448
|
+
)
|
|
449
|
+
if prefix == self.module:
|
|
450
|
+
self.module_symbols[name] = ("Class", qualified)
|
|
451
|
+
self.class_members.setdefault(qualified, {})
|
|
452
|
+
class_ref = self.ref("Class", qualified)
|
|
453
|
+
for child in statement.body:
|
|
454
|
+
self._declare(child, prefix=qualified, parent=class_ref,
|
|
455
|
+
in_class=True, class_qn=qualified, depth=depth + 1)
|
|
456
|
+
return
|
|
457
|
+
|
|
458
|
+
# Diğer deyimlerin gövdesi bildirim geçişinde taranmaz (L1 odaklı).
|
|
459
|
+
return
|
|
460
|
+
|
|
461
|
+
# -- route kuralları (seçili L3) ---------------------------------------------
|
|
462
|
+
|
|
463
|
+
def _collect_routes(self, function_node: ast.stmt, handler_qn: str, handler_kind: str) -> None:
|
|
464
|
+
for decorator in getattr(function_node, "decorator_list", []):
|
|
465
|
+
if not isinstance(decorator, ast.Call):
|
|
466
|
+
continue
|
|
467
|
+
func = decorator.func
|
|
468
|
+
if not isinstance(func, ast.Attribute):
|
|
469
|
+
# Bare ad dekoratörü (@get vb.) rota taşıyıcısı değildir;
|
|
470
|
+
# yaygın dekoratörler (@property vb.) zaten eşleşmez — sessiz atlanır.
|
|
471
|
+
continue
|
|
472
|
+
if not isinstance(func.value, ast.Name):
|
|
473
|
+
# Takım denetimi bulgusu: @routers['main'].get('/x') gibi
|
|
474
|
+
# basit-ad olmayan taşıyıcılar SESSİZCE atlanıyordu;
|
|
475
|
+
# 'sessiz kesim yoktur' disipliniyle açık uyarı yazılır.
|
|
476
|
+
if func.attr in HTTP_VERB_DECORATORS or func.attr in ROUTE_NAMED_DECORATORS:
|
|
477
|
+
self.collector.add_warning(
|
|
478
|
+
f"{self.path}: '{ast.unparse(func)}' dekoratör taşıyıcısı basit ad değil; "
|
|
479
|
+
f"{handler_qn} için endpoint üretilmedi"
|
|
480
|
+
)
|
|
481
|
+
continue
|
|
482
|
+
carrier = func.value.id
|
|
483
|
+
attr = func.attr
|
|
484
|
+
verbs: List[str] = []
|
|
485
|
+
path: Optional[str] = None
|
|
486
|
+
|
|
487
|
+
if attr in HTTP_VERB_DECORATORS:
|
|
488
|
+
verbs = [attr.upper()]
|
|
489
|
+
path = self._literal_str(decorator, 0)
|
|
490
|
+
elif attr in ROUTE_NAMED_DECORATORS:
|
|
491
|
+
path = self._literal_str(decorator, 0)
|
|
492
|
+
verbs = self._methods_kwarg(decorator)
|
|
493
|
+
else:
|
|
494
|
+
continue
|
|
495
|
+
|
|
496
|
+
if path is None:
|
|
497
|
+
self.collector.add_warning(
|
|
498
|
+
f"{self.path}: '{carrier}.{attr}' dekoratör yolu literal string değil; "
|
|
499
|
+
f"{handler_qn} için endpoint üretilmedi"
|
|
500
|
+
)
|
|
501
|
+
continue
|
|
502
|
+
|
|
503
|
+
for verb in verbs:
|
|
504
|
+
endpoint_qn = f"{verb} {path}"
|
|
505
|
+
self.collector.add_node(
|
|
506
|
+
"Endpoint", endpoint_qn, self.path,
|
|
507
|
+
attributes={"method": verb, "path": path},
|
|
508
|
+
)
|
|
509
|
+
self.collector.add_route(
|
|
510
|
+
self.ref("Endpoint", endpoint_qn),
|
|
511
|
+
self.ref(handler_kind, handler_qn),
|
|
512
|
+
self.evidence(
|
|
513
|
+
"route-attribute",
|
|
514
|
+
decorator,
|
|
515
|
+
f"ROUTES_TO: {ast.unparse(decorator)} dekoratörü {handler_qn} "
|
|
516
|
+
"handler'ına bağlı (verified).",
|
|
517
|
+
),
|
|
518
|
+
)
|
|
519
|
+
|
|
520
|
+
def _literal_str(self, call: ast.Call, position: int) -> Optional[str]:
|
|
521
|
+
if position < len(call.args):
|
|
522
|
+
arg = call.args[position]
|
|
523
|
+
if isinstance(arg, ast.Constant) and isinstance(arg.value, str):
|
|
524
|
+
return arg.value
|
|
525
|
+
return None
|
|
526
|
+
|
|
527
|
+
def _methods_kwarg(self, call: ast.Call) -> List[str]:
|
|
528
|
+
for keyword in call.keywords:
|
|
529
|
+
if keyword.arg == "methods" and isinstance(keyword.value, ast.List):
|
|
530
|
+
verbs = []
|
|
531
|
+
for element in keyword.value.elts:
|
|
532
|
+
if isinstance(element, ast.Constant) and isinstance(element.value, str):
|
|
533
|
+
verb = element.value.strip().upper()
|
|
534
|
+
if verb:
|
|
535
|
+
verbs.append(verb)
|
|
536
|
+
if verbs:
|
|
537
|
+
return verbs
|
|
538
|
+
return ["GET"] # Flask varsayılanı: methods belirtilmezse GET.
|
|
539
|
+
|
|
540
|
+
# -- import tablosu (yalnızca modül düzeyi) -----------------------------------
|
|
541
|
+
|
|
542
|
+
def _register_imports(self, body: List[ast.stmt]) -> None:
|
|
543
|
+
for statement in body:
|
|
544
|
+
if isinstance(statement, ast.Import):
|
|
545
|
+
for alias in statement.names:
|
|
546
|
+
bind = alias.asname or alias.name.split(".")[0]
|
|
547
|
+
self.import_bindings[bind] = ("module", alias.name)
|
|
548
|
+
elif isinstance(statement, ast.ImportFrom):
|
|
549
|
+
level = statement.level or 0
|
|
550
|
+
# Mutlak import (level=0) taban PAKET ALMAZ; yalnızca göreli
|
|
551
|
+
# import (level>0) dosyanın paketine göre çözülür.
|
|
552
|
+
base = self._relative_import_base(level) if level > 0 else ""
|
|
553
|
+
if statement.module is None and level > 0:
|
|
554
|
+
# from . import altmodul
|
|
555
|
+
for alias in statement.names:
|
|
556
|
+
bind = alias.asname or alias.name
|
|
557
|
+
dotted = f"{base}.{alias.name}" if base else alias.name
|
|
558
|
+
self.import_bindings[bind] = ("module", dotted)
|
|
559
|
+
else:
|
|
560
|
+
dotted_module = statement.module or ""
|
|
561
|
+
if base and dotted_module:
|
|
562
|
+
dotted_module = f"{base}.{dotted_module}"
|
|
563
|
+
elif base:
|
|
564
|
+
dotted_module = base
|
|
565
|
+
for alias in statement.names:
|
|
566
|
+
bind = alias.asname or alias.name
|
|
567
|
+
self.import_bindings[bind] = ("symbol", dotted_module, alias.name)
|
|
568
|
+
|
|
569
|
+
def _relative_import_base(self, level: int) -> str:
|
|
570
|
+
"""Göreli import tabanı: level=1 → dosyanın paketi; level=n → (n-1) üst paket."""
|
|
571
|
+
package_parts = self.module.split(".")[:-1] if "." in self.module else []
|
|
572
|
+
drop = level - 1
|
|
573
|
+
if drop > len(package_parts):
|
|
574
|
+
return ""
|
|
575
|
+
if drop == 0:
|
|
576
|
+
return ".".join(package_parts)
|
|
577
|
+
return ".".join(package_parts[: len(package_parts) - drop])
|
|
578
|
+
|
|
579
|
+
# -- geçiş 2: çağrı çözümleme ---------------------------------------------------
|
|
580
|
+
|
|
581
|
+
def resolve_calls(self) -> None:
|
|
582
|
+
for node, kind, qualified, class_qn in self.callables:
|
|
583
|
+
for statement in node.body:
|
|
584
|
+
self._walk_calls(statement, (kind, qualified, class_qn), depth=1)
|
|
585
|
+
|
|
586
|
+
def _walk_calls(
|
|
587
|
+
self,
|
|
588
|
+
statement: ast.AST,
|
|
589
|
+
owner: Tuple[str, str, Optional[str]],
|
|
590
|
+
depth: int,
|
|
591
|
+
) -> None:
|
|
592
|
+
if depth > MAX_AST_DEPTH:
|
|
593
|
+
self.depth_exceeded = True
|
|
594
|
+
return
|
|
595
|
+
|
|
596
|
+
if isinstance(statement, ast.Call):
|
|
597
|
+
self._resolve_call(statement, owner)
|
|
598
|
+
|
|
599
|
+
# İç içe bildirimlere İNİLMEZ: kendi gövdeleri, bildirim geçişinde
|
|
600
|
+
# kaydedildikleri kendi callables kaydıyla ayrı sahiplikle gezilir.
|
|
601
|
+
for child in ast.iter_child_nodes(statement):
|
|
602
|
+
if isinstance(child, (ast.FunctionDef, ast.AsyncFunctionDef, ast.ClassDef)):
|
|
603
|
+
continue
|
|
604
|
+
self._walk_calls(child, owner, depth + 1)
|
|
605
|
+
|
|
606
|
+
def _resolve_call(self, call: ast.Call, owner: Tuple[str, str, Optional[str]]) -> None:
|
|
607
|
+
owner_kind, owner_qn, owner_class_qn = owner
|
|
608
|
+
caller_ref = self.ref(owner_kind, owner_qn)
|
|
609
|
+
func = call.func
|
|
610
|
+
|
|
611
|
+
def finish(
|
|
612
|
+
resolution: str,
|
|
613
|
+
target_ref: Dict[str, Any],
|
|
614
|
+
rationale: str,
|
|
615
|
+
ambiguity: Optional[Dict[str, Any]] = None,
|
|
616
|
+
) -> None:
|
|
617
|
+
self.collector.add_calls(
|
|
618
|
+
caller_ref,
|
|
619
|
+
target_ref,
|
|
620
|
+
resolution,
|
|
621
|
+
self.evidence("ast-span", call, rationale),
|
|
622
|
+
ambiguity,
|
|
623
|
+
)
|
|
624
|
+
|
|
625
|
+
if isinstance(func, ast.Name):
|
|
626
|
+
name = func.id
|
|
627
|
+
if name in self.module_symbols:
|
|
628
|
+
target_kind, target_qn = self.module_symbols[name]
|
|
629
|
+
finish(
|
|
630
|
+
"verified", self.ref(target_kind, target_qn),
|
|
631
|
+
f"CALLS: {owner_qn} → {target_qn} hedefi aynı modülde tanımlı "
|
|
632
|
+
f"'{name}' AST isim bağlamıyla çözümlendi (verified).",
|
|
633
|
+
)
|
|
634
|
+
elif name in self.import_bindings:
|
|
635
|
+
self._resolve_imported(name, [], owner_qn, finish)
|
|
636
|
+
else:
|
|
637
|
+
finish(
|
|
638
|
+
"unresolved", self.external_ref(name),
|
|
639
|
+
f"CALLS: {owner_qn} → {name} çözümlenemedi (unresolved); "
|
|
640
|
+
"uydurma hedef üretilmedi.",
|
|
641
|
+
)
|
|
642
|
+
return
|
|
643
|
+
|
|
644
|
+
if isinstance(func, ast.Attribute):
|
|
645
|
+
chain = self._dotted_chain(func)
|
|
646
|
+
if chain is None:
|
|
647
|
+
source = ast.unparse(func)
|
|
648
|
+
finish(
|
|
649
|
+
"unresolved", self.external_ref(source),
|
|
650
|
+
f"CALLS: {owner_qn} → {source} çözümlenemedi (unresolved); "
|
|
651
|
+
"uydurma hedef üretilmedi.",
|
|
652
|
+
)
|
|
653
|
+
return
|
|
654
|
+
|
|
655
|
+
root, rest = chain[0], chain[1:]
|
|
656
|
+
|
|
657
|
+
# self.<m>: sarmalayan sınıfın üye tablosu (lexical olarak kesin).
|
|
658
|
+
if root == "self" and owner_class_qn is not None and rest:
|
|
659
|
+
member = self.class_members.get(owner_class_qn, {}).get(rest[0])
|
|
660
|
+
if member is not None:
|
|
661
|
+
finish(
|
|
662
|
+
"verified", self.ref(member[0], member[1]),
|
|
663
|
+
f"CALLS: {owner_qn} → {member[1]} hedefi 'self.{rest[0]}' "
|
|
664
|
+
f"sarmalayan sınıf {owner_class_qn} üye tablosuyla çözümlendi (verified).",
|
|
665
|
+
)
|
|
666
|
+
else:
|
|
667
|
+
finish(
|
|
668
|
+
"unresolved", self.external_ref(".".join(chain)),
|
|
669
|
+
f"CALLS: {owner_qn} → {'.'.join(chain)} çözümlenemedi (unresolved); "
|
|
670
|
+
"uydurma hedef üretilmedi.",
|
|
671
|
+
)
|
|
672
|
+
return
|
|
673
|
+
|
|
674
|
+
# AynıModülSınıfı.<m>: sınıf üye tablosu.
|
|
675
|
+
if len(rest) == 1 and root in self.module_symbols:
|
|
676
|
+
target_kind, target_qn = self.module_symbols[root]
|
|
677
|
+
if target_kind == "Class":
|
|
678
|
+
member = self.class_members.get(target_qn, {}).get(rest[0])
|
|
679
|
+
if member is not None:
|
|
680
|
+
finish(
|
|
681
|
+
"verified", self.ref(member[0], member[1]),
|
|
682
|
+
f"CALLS: {owner_qn} → {member[1]} hedefi aynı modülde tanımlı "
|
|
683
|
+
f"{target_qn} sınıf üye tablosuyla çözümlendi (verified).",
|
|
684
|
+
)
|
|
685
|
+
else:
|
|
686
|
+
finish(
|
|
687
|
+
"unresolved", self.external_ref(".".join(chain)),
|
|
688
|
+
f"CALLS: {owner_qn} → {'.'.join(chain)} çözümlenemedi (unresolved); "
|
|
689
|
+
"uydurma hedef üretilmedi.",
|
|
690
|
+
)
|
|
691
|
+
return
|
|
692
|
+
# Modül düzeyi fonksiyon niteliği (ör. func.attr) çözümlenmez.
|
|
693
|
+
finish(
|
|
694
|
+
"unresolved", self.external_ref(".".join(chain)),
|
|
695
|
+
f"CALLS: {owner_qn} → {'.'.join(chain)} çözümlenemedi (unresolved); "
|
|
696
|
+
"uydurma hedef üretilmedi.",
|
|
697
|
+
)
|
|
698
|
+
return
|
|
699
|
+
|
|
700
|
+
if root in self.import_bindings:
|
|
701
|
+
self._resolve_imported(root, rest, owner_qn, finish)
|
|
702
|
+
return
|
|
703
|
+
|
|
704
|
+
finish(
|
|
705
|
+
"unresolved", self.external_ref(".".join(chain)),
|
|
706
|
+
f"CALLS: {owner_qn} → {'.'.join(chain)} çözümlenemedi (unresolved); "
|
|
707
|
+
"uydurma hedef üretilmedi.",
|
|
708
|
+
)
|
|
709
|
+
return
|
|
710
|
+
|
|
711
|
+
source = ast.unparse(func)
|
|
712
|
+
finish(
|
|
713
|
+
"unresolved", self.external_ref(source),
|
|
714
|
+
f"CALLS: {owner_qn} → {source} çözümlenemedi (unresolved); "
|
|
715
|
+
"uydurma hedef üretilmedi.",
|
|
716
|
+
)
|
|
717
|
+
|
|
718
|
+
def _dotted_chain(self, node: ast.AST) -> Optional[List[str]]:
|
|
719
|
+
"""Attribute/Name zincirini kökten sona ad listesine indirir; değilse None."""
|
|
720
|
+
parts: List[str] = []
|
|
721
|
+
current: ast.AST = node
|
|
722
|
+
while isinstance(current, ast.Attribute):
|
|
723
|
+
parts.append(current.attr)
|
|
724
|
+
current = current.value
|
|
725
|
+
if not isinstance(current, ast.Name):
|
|
726
|
+
return None
|
|
727
|
+
parts.append(current.id)
|
|
728
|
+
parts.reverse()
|
|
729
|
+
return parts
|
|
730
|
+
|
|
731
|
+
def _resolve_imported(
|
|
732
|
+
self,
|
|
733
|
+
binding_name: str,
|
|
734
|
+
rest: List[str],
|
|
735
|
+
owner_qn: str,
|
|
736
|
+
finish: Any,
|
|
737
|
+
) -> None:
|
|
738
|
+
binding = self.import_bindings.get(binding_name)
|
|
739
|
+
if binding is None: # savunma: çağıran zaten kontrol etti
|
|
740
|
+
return
|
|
741
|
+
module_set = self.collector.module_set
|
|
742
|
+
|
|
743
|
+
if binding[0] == "module":
|
|
744
|
+
dotted = binding[1]
|
|
745
|
+
symbol_parts = list(rest)
|
|
746
|
+
# Paket zinciri: dotted + rest[0] da analiz setinde modül olabilir.
|
|
747
|
+
while (
|
|
748
|
+
symbol_parts
|
|
749
|
+
and len(symbol_parts) > 1
|
|
750
|
+
and f"{dotted}.{symbol_parts[0]}" in module_set
|
|
751
|
+
):
|
|
752
|
+
dotted = f"{dotted}.{symbol_parts[0]}"
|
|
753
|
+
symbol_parts = symbol_parts[1:]
|
|
754
|
+
|
|
755
|
+
if symbol_parts:
|
|
756
|
+
symbol_name = symbol_parts[0]
|
|
757
|
+
target_qn = f"{dotted}.{symbol_name}"
|
|
758
|
+
registry_entry = self.collector.symbol_registry.get(target_qn)
|
|
759
|
+
if dotted in module_set and registry_entry is not None:
|
|
760
|
+
target_kind, target_relative_path = registry_entry
|
|
761
|
+
finish(
|
|
762
|
+
"heuristic",
|
|
763
|
+
{"kind": target_kind, "qualifiedName": target_qn,
|
|
764
|
+
"relativePath": target_relative_path},
|
|
765
|
+
f"CALLS: {owner_qn} → {target_qn} import edilen modül sembolü "
|
|
766
|
+
"üzerinden çözümlendi (heuristic; tam type inference yok).",
|
|
767
|
+
{
|
|
768
|
+
"candidates": [target_qn],
|
|
769
|
+
"reason": "import edilen modül sembolü; Python ad bağlamı "
|
|
770
|
+
"dinamiktir, kesin çözümleme yapılmadı",
|
|
771
|
+
},
|
|
772
|
+
)
|
|
773
|
+
else:
|
|
774
|
+
finish(
|
|
775
|
+
"heuristic",
|
|
776
|
+
self.external_ref(target_qn),
|
|
777
|
+
f"CALLS: {owner_qn} → {target_qn} import bildirimi dayanağıyla "
|
|
778
|
+
"dış sembol olarak eşlendi (heuristic; semantik doğrulama yok).",
|
|
779
|
+
{
|
|
780
|
+
"candidates": [target_qn],
|
|
781
|
+
"reason": "analiz seti dışı import; semantik doğrulama yok",
|
|
782
|
+
},
|
|
783
|
+
)
|
|
784
|
+
else:
|
|
785
|
+
finish(
|
|
786
|
+
"unresolved", self.external_ref(binding_name),
|
|
787
|
+
f"CALLS: {owner_qn} → {binding_name} çözümlenemedi (unresolved); "
|
|
788
|
+
"uydurma hedef üretilmedi.",
|
|
789
|
+
)
|
|
790
|
+
return
|
|
791
|
+
|
|
792
|
+
# ("symbol", module_dotted, symbol_name)
|
|
793
|
+
_, dotted_module, symbol_name = binding
|
|
794
|
+
symbol_qn = f"{dotted_module}.{symbol_name}" if dotted_module else symbol_name
|
|
795
|
+
registry_entry = self.collector.symbol_registry.get(symbol_qn)
|
|
796
|
+
|
|
797
|
+
if registry_entry is not None:
|
|
798
|
+
target_kind, target_relative_path = registry_entry
|
|
799
|
+
if len(rest) == 1 and target_kind == "Class":
|
|
800
|
+
class_members = self.collector.class_member_registry.get(symbol_qn, {})
|
|
801
|
+
member = class_members.get(rest[0])
|
|
802
|
+
if member is not None:
|
|
803
|
+
member_kind, member_qn, member_path = member
|
|
804
|
+
finish(
|
|
805
|
+
"heuristic",
|
|
806
|
+
{"kind": member_kind, "qualifiedName": member_qn,
|
|
807
|
+
"relativePath": member_path},
|
|
808
|
+
f"CALLS: {owner_qn} → {member_qn} import edilen sınıf sembolü "
|
|
809
|
+
"üye tablosuyla çözümlendi (heuristic; tam type inference yok).",
|
|
810
|
+
{
|
|
811
|
+
"candidates": [member_qn],
|
|
812
|
+
"reason": "import edilen modül sembolü; Python ad bağlamı "
|
|
813
|
+
"dinamiktir, kesin çözümleme yapılmadı",
|
|
814
|
+
},
|
|
815
|
+
)
|
|
816
|
+
return
|
|
817
|
+
finish(
|
|
818
|
+
"heuristic",
|
|
819
|
+
{"kind": target_kind, "qualifiedName": symbol_qn,
|
|
820
|
+
"relativePath": target_relative_path},
|
|
821
|
+
f"CALLS: {owner_qn} → {symbol_qn} import edilen modül sembolü "
|
|
822
|
+
"üzerinden çözümlendi (heuristic; tam type inference yok).",
|
|
823
|
+
{
|
|
824
|
+
"candidates": [symbol_qn],
|
|
825
|
+
"reason": "import edilen modül sembolü; Python ad bağlamı "
|
|
826
|
+
"dinamiktir, kesin çözümleme yapılmadı",
|
|
827
|
+
},
|
|
828
|
+
)
|
|
829
|
+
return
|
|
830
|
+
|
|
831
|
+
# Analiz seti dışı import sembolü: import bildirimi metinsel dayanaktır.
|
|
832
|
+
external_qn = f"{symbol_qn}.{'.'.join(rest)}" if rest else symbol_qn
|
|
833
|
+
finish(
|
|
834
|
+
"heuristic",
|
|
835
|
+
self.external_ref(external_qn),
|
|
836
|
+
f"CALLS: {owner_qn} → {external_qn} import bildirimi dayanağıyla dış "
|
|
837
|
+
"sembol olarak eşlendi (heuristic; semantik doğrulama yok).",
|
|
838
|
+
{
|
|
839
|
+
"candidates": [external_qn],
|
|
840
|
+
"reason": "analiz seti dışı import; semantik doğrulama yok",
|
|
841
|
+
},
|
|
842
|
+
)
|
|
843
|
+
|
|
844
|
+
|
|
845
|
+
class RequestCollector:
|
|
846
|
+
"""İstek düzeyi node/edge/evidence toplayıcı — deterministik çıktı için."""
|
|
847
|
+
|
|
848
|
+
def __init__(self) -> None:
|
|
849
|
+
self._nodes: Dict[Tuple[str, str, str], Dict[str, Any]] = {}
|
|
850
|
+
self._edges: Dict[Tuple[str, str, str, str], Dict[str, Any]] = {}
|
|
851
|
+
self._edge_order: List[Tuple[str, str, str, str]] = []
|
|
852
|
+
self._evidence_keys: set = set()
|
|
853
|
+
self.warnings: List[str] = []
|
|
854
|
+
self.diagnostics: List[Dict[str, Any]] = []
|
|
855
|
+
self.module_set: set = set()
|
|
856
|
+
# qualified_name → (kind, relative_path)
|
|
857
|
+
self.symbol_registry: Dict[str, Tuple[str, str]] = {}
|
|
858
|
+
# class_qualified_name → {üye adı → (kind, qn, relative_path)}
|
|
859
|
+
self.class_member_registry: Dict[str, Dict[str, Tuple[str, str, str]]] = {}
|
|
860
|
+
|
|
861
|
+
def add_file_node(self, relative_path: str, source_hash: str) -> None:
|
|
862
|
+
self.add_node("File", relative_path, relative_path,
|
|
863
|
+
attributes={"sourceHash": source_hash})
|
|
864
|
+
|
|
865
|
+
def add_node(
|
|
866
|
+
self,
|
|
867
|
+
kind: str,
|
|
868
|
+
qualified_name: str,
|
|
869
|
+
relative_path: Optional[str],
|
|
870
|
+
attributes: Optional[Dict[str, Any]] = None,
|
|
871
|
+
) -> None:
|
|
872
|
+
key = (kind, qualified_name, relative_path or "")
|
|
873
|
+
if key in self._nodes:
|
|
874
|
+
return
|
|
875
|
+
node: Dict[str, Any] = {"kind": kind, "qualifiedName": qualified_name}
|
|
876
|
+
node["language"] = "python"
|
|
877
|
+
if relative_path is not None:
|
|
878
|
+
node["relativePath"] = relative_path
|
|
879
|
+
node["attributes"] = attributes if attributes is not None else {}
|
|
880
|
+
self._nodes[key] = node
|
|
881
|
+
if kind == "File" and relative_path is not None:
|
|
882
|
+
self.module_set.add(module_name_from_path(relative_path))
|
|
883
|
+
|
|
884
|
+
def add_contains(self, parent_ref: Dict[str, Any], child_ref: Dict[str, Any],
|
|
885
|
+
evidence_item: Dict[str, Any]) -> None:
|
|
886
|
+
self._add_edge("CONTAINS", parent_ref, child_ref, "verified", [evidence_item], None)
|
|
887
|
+
|
|
888
|
+
def add_calls(
|
|
889
|
+
self,
|
|
890
|
+
caller_ref: Dict[str, Any],
|
|
891
|
+
target_ref: Dict[str, Any],
|
|
892
|
+
resolution: str,
|
|
893
|
+
evidence_item: Dict[str, Any],
|
|
894
|
+
ambiguity: Optional[Dict[str, Any]],
|
|
895
|
+
) -> None:
|
|
896
|
+
self._add_edge("CALLS", caller_ref, target_ref, resolution, [evidence_item], ambiguity)
|
|
897
|
+
|
|
898
|
+
def add_route(self, endpoint_ref: Dict[str, Any], handler_ref: Dict[str, Any],
|
|
899
|
+
evidence_item: Dict[str, Any]) -> None:
|
|
900
|
+
self._add_edge("ROUTES_TO", endpoint_ref, handler_ref, "verified", [evidence_item], None)
|
|
901
|
+
|
|
902
|
+
def register_symbol(self, qualified_name: str, kind: str, relative_path: str) -> None:
|
|
903
|
+
self.symbol_registry[qualified_name] = (kind, relative_path)
|
|
904
|
+
|
|
905
|
+
def register_class_members(self, class_qn: str,
|
|
906
|
+
members: Dict[str, Tuple[str, str, str]]) -> None:
|
|
907
|
+
self.class_member_registry.setdefault(class_qn, {}).update(members)
|
|
908
|
+
|
|
909
|
+
def add_warning(self, message: str) -> None:
|
|
910
|
+
self.warnings.append(message)
|
|
911
|
+
|
|
912
|
+
def add_diagnostic(self, relative_path: str, code: str, message: str, line: int) -> None:
|
|
913
|
+
self.diagnostics.append(
|
|
914
|
+
{"relativePath": relative_path, "code": code, "message": message, "line": line}
|
|
915
|
+
)
|
|
916
|
+
|
|
917
|
+
def _add_edge(
|
|
918
|
+
self,
|
|
919
|
+
kind: str,
|
|
920
|
+
from_ref: Dict[str, Any],
|
|
921
|
+
to_ref: Dict[str, Any],
|
|
922
|
+
resolution: str,
|
|
923
|
+
evidence_items: List[Dict[str, Any]],
|
|
924
|
+
ambiguity: Optional[Dict[str, Any]],
|
|
925
|
+
) -> None:
|
|
926
|
+
key = (kind, canonical(from_ref), canonical(to_ref), resolution)
|
|
927
|
+
# TŞ §8 invariant (ii): dangling edge yok — dış kaynaklar AÇIK node.
|
|
928
|
+
# UnknownExternal hedef ilk referans alındığında node kümesine girer.
|
|
929
|
+
if to_ref.get("kind") == "UnknownExternal":
|
|
930
|
+
self.add_node("UnknownExternal", to_ref["qualifiedName"], None)
|
|
931
|
+
edge = self._edges.get(key)
|
|
932
|
+
if edge is None:
|
|
933
|
+
edge = {"kind": kind, "from": from_ref, "to": to_ref, "resolution": resolution}
|
|
934
|
+
edge["evidence"] = []
|
|
935
|
+
if ambiguity is not None:
|
|
936
|
+
edge["ambiguity"] = ambiguity
|
|
937
|
+
self._edges[key] = edge
|
|
938
|
+
self._edge_order.append(key)
|
|
939
|
+
for item in evidence_items:
|
|
940
|
+
evidence_key = canonical(item)
|
|
941
|
+
self._evidence_keys.add(evidence_key)
|
|
942
|
+
if all(canonical(existing) != evidence_key for existing in edge["evidence"]):
|
|
943
|
+
edge["evidence"].append(item)
|
|
944
|
+
|
|
945
|
+
# -- çıktı ---------------------------------------------------------------------
|
|
946
|
+
|
|
947
|
+
def response(self, request_id: Any, max_nodes: Optional[int]) -> Dict[str, Any]:
|
|
948
|
+
nodes = sorted(
|
|
949
|
+
self._nodes.values(),
|
|
950
|
+
key=lambda node: (node["kind"], node["qualifiedName"],
|
|
951
|
+
node.get("relativePath") or ""),
|
|
952
|
+
)
|
|
953
|
+
edges = sorted(
|
|
954
|
+
(self._edges[key] for key in self._edge_order),
|
|
955
|
+
key=lambda edge: (
|
|
956
|
+
edge["kind"],
|
|
957
|
+
edge["from"]["kind"],
|
|
958
|
+
edge["from"]["qualifiedName"],
|
|
959
|
+
edge["from"].get("relativePath") or "",
|
|
960
|
+
edge["to"]["kind"],
|
|
961
|
+
edge["to"]["qualifiedName"],
|
|
962
|
+
edge["to"].get("relativePath") or "",
|
|
963
|
+
edge["resolution"],
|
|
964
|
+
),
|
|
965
|
+
)
|
|
966
|
+
|
|
967
|
+
diagnostics = list(self.diagnostics)
|
|
968
|
+
|
|
969
|
+
if max_nodes is not None and len(nodes) > max_nodes:
|
|
970
|
+
kept = nodes[:max_nodes]
|
|
971
|
+
kept_keys = {
|
|
972
|
+
(node["kind"], node["qualifiedName"], node.get("relativePath") or "")
|
|
973
|
+
for node in kept
|
|
974
|
+
}
|
|
975
|
+
edges = [
|
|
976
|
+
edge for edge in edges
|
|
977
|
+
if (edge["from"]["kind"], edge["from"]["qualifiedName"],
|
|
978
|
+
edge["from"].get("relativePath") or "") in kept_keys
|
|
979
|
+
and (edge["to"]["kind"], edge["to"]["qualifiedName"],
|
|
980
|
+
edge["to"].get("relativePath") or "") in kept_keys
|
|
981
|
+
]
|
|
982
|
+
nodes = kept
|
|
983
|
+
diagnostics.append(
|
|
984
|
+
{
|
|
985
|
+
"relativePath": "",
|
|
986
|
+
"code": "RESPONSE_TRUNCATED",
|
|
987
|
+
"message": f"node bütçesi aşıldı: {max_nodes} node yayınlandı; "
|
|
988
|
+
"aşan node'lar ve uçları yayınlanmayan kenarlar düşürüldü",
|
|
989
|
+
"line": 0,
|
|
990
|
+
}
|
|
991
|
+
)
|
|
992
|
+
|
|
993
|
+
# Üst düzey evidence: yayımlanan kenarların kanıt kümesi (tekil, sıralı).
|
|
994
|
+
evidence: Dict[str, Dict[str, Any]] = {}
|
|
995
|
+
for edge in edges:
|
|
996
|
+
for item in edge["evidence"]:
|
|
997
|
+
evidence.setdefault(canonical(item), item)
|
|
998
|
+
evidence_list = [evidence[key] for key in sorted(evidence.keys())]
|
|
999
|
+
|
|
1000
|
+
# Çıkışta sert doğrulama: worker liste dışı tür üretemez.
|
|
1001
|
+
for node in nodes:
|
|
1002
|
+
if node["kind"] not in NODE_KINDS:
|
|
1003
|
+
raise ValueError(f"katalog dışı node türü: {node['kind']}")
|
|
1004
|
+
for edge in edges:
|
|
1005
|
+
if edge["kind"] not in EDGE_KINDS or edge["resolution"] not in RESOLUTIONS:
|
|
1006
|
+
raise ValueError("katalog dışı kenar")
|
|
1007
|
+
for item in evidence_list:
|
|
1008
|
+
if item["kind"] not in EVIDENCE_KINDS:
|
|
1009
|
+
raise ValueError(f"katalog dışı evidence türü: {item['kind']}")
|
|
1010
|
+
|
|
1011
|
+
total_edges = len(edges)
|
|
1012
|
+
verified_edges = sum(1 for edge in edges if edge["resolution"] == "verified")
|
|
1013
|
+
coverage = round(verified_edges / total_edges, 4) if total_edges > 0 else 1.0
|
|
1014
|
+
|
|
1015
|
+
response: Dict[str, Any] = {
|
|
1016
|
+
"id": request_id,
|
|
1017
|
+
"protocolVersion": PROTOCOL_VERSION,
|
|
1018
|
+
"status": "partial" if diagnostics else "ready",
|
|
1019
|
+
"worker": {"analyzerId": ANALYZER_ID, "analyzerVersion": ANALYZER_VERSION},
|
|
1020
|
+
"capabilities": {
|
|
1021
|
+
"astParse": True,
|
|
1022
|
+
"symbolResolution": True,
|
|
1023
|
+
"containsEdges": True,
|
|
1024
|
+
"callEdges": True,
|
|
1025
|
+
"importEdges": False,
|
|
1026
|
+
"routeDetection": "python-decorator-route-pattern",
|
|
1027
|
+
"frameworkLinkers": False,
|
|
1028
|
+
},
|
|
1029
|
+
"coverageRatio": coverage,
|
|
1030
|
+
"unsupportedConstructs": list(UNSUPPORTED_CONSTRUCTS),
|
|
1031
|
+
"warnings": list(self.warnings),
|
|
1032
|
+
"diagnostics": diagnostics,
|
|
1033
|
+
"nodes": nodes,
|
|
1034
|
+
"edges": edges,
|
|
1035
|
+
"evidence": evidence_list,
|
|
1036
|
+
}
|
|
1037
|
+
return response
|
|
1038
|
+
|
|
1039
|
+
|
|
1040
|
+
# ---------------------------------------------------------------------------
|
|
1041
|
+
# Ana döngü
|
|
1042
|
+
# ---------------------------------------------------------------------------
|
|
1043
|
+
|
|
1044
|
+
def analyze_request(request: Dict[str, Any]) -> Dict[str, Any]:
|
|
1045
|
+
collector = RequestCollector()
|
|
1046
|
+
|
|
1047
|
+
# Ayrıştırma: sözdizimi hatası HATA DEĞİLDİR → tanı + File node (L0),
|
|
1048
|
+
# diğer dosyaların grafiği üretilmeye devam eder (status: partial).
|
|
1049
|
+
analyzers: List[FileAnalyzer] = []
|
|
1050
|
+
for entry in request["files"]:
|
|
1051
|
+
relative_path = entry["path"]
|
|
1052
|
+
content = entry["content"]
|
|
1053
|
+
try:
|
|
1054
|
+
tree = ast.parse(content, filename=relative_path)
|
|
1055
|
+
except SyntaxError as error:
|
|
1056
|
+
collector.add_diagnostic(
|
|
1057
|
+
relative_path,
|
|
1058
|
+
"SyntaxError",
|
|
1059
|
+
str(error.msg or "sözdizimi hatası"),
|
|
1060
|
+
error.lineno or 0,
|
|
1061
|
+
)
|
|
1062
|
+
collector.add_file_node(relative_path, sha256_hex(content))
|
|
1063
|
+
continue
|
|
1064
|
+
except (RecursionError, MemoryError, ValueError) as error:
|
|
1065
|
+
collector.add_diagnostic(
|
|
1066
|
+
relative_path,
|
|
1067
|
+
"ADAPTER_INTERNAL",
|
|
1068
|
+
f"AST ayrıştırması tamamlanamadı: {error}",
|
|
1069
|
+
0,
|
|
1070
|
+
)
|
|
1071
|
+
collector.add_file_node(relative_path, sha256_hex(content))
|
|
1072
|
+
continue
|
|
1073
|
+
analyzers.append(FileAnalyzer(relative_path, content, tree, collector))
|
|
1074
|
+
|
|
1075
|
+
# Geçiş 1: bildirimler (File/Function/Method/Class/Endpoint + CONTAINS
|
|
1076
|
+
# + ROUTES_TO) ve global sembol kaydı.
|
|
1077
|
+
for analyzer in analyzers:
|
|
1078
|
+
analyzer.analyze()
|
|
1079
|
+
if analyzer.depth_exceeded:
|
|
1080
|
+
collector.add_diagnostic(
|
|
1081
|
+
analyzer.path,
|
|
1082
|
+
"ADAPTER_INTERNAL",
|
|
1083
|
+
f"AST gezinme derinliği {MAX_AST_DEPTH} aşıldı; derin alt ağaçlar atlandı",
|
|
1084
|
+
0,
|
|
1085
|
+
)
|
|
1086
|
+
|
|
1087
|
+
# Geçiş 2: çağrı çözümleme (tüm modüllerin sembolleri kayıtlı olduktan sonra;
|
|
1088
|
+
# çok dosyalı import zincirleri doğru hedefe bağlanır).
|
|
1089
|
+
for analyzer in analyzers:
|
|
1090
|
+
analyzer.resolve_calls()
|
|
1091
|
+
|
|
1092
|
+
return collector.response(request["id"], request.get("maxNodes"))
|
|
1093
|
+
|
|
1094
|
+
|
|
1095
|
+
def handle_line(line: str) -> Dict[str, Any]:
|
|
1096
|
+
try:
|
|
1097
|
+
payload = json.loads(line)
|
|
1098
|
+
except (ValueError, RecursionError) as error:
|
|
1099
|
+
# RecursionError da yakalanır (takım denetimi bulgusu): çok derin
|
|
1100
|
+
# iç içe JSON (ör. 5000 katman dizi) decoder'da RecursionError
|
|
1101
|
+
# fırlatır; yakalanmazsa süreci öldürür ve 'bozuk satır döngüyü
|
|
1102
|
+
# düşürmez' sözleşmesi ihlal olur (tests/python-worker.test.ts
|
|
1103
|
+
# 'derin iç içe JSON satırı' regresyon testi).
|
|
1104
|
+
return error_response(None, "INVALID_ARGUMENT", f"satır geçerli JSON değil: {error}")
|
|
1105
|
+
|
|
1106
|
+
request, error = validate_request(payload)
|
|
1107
|
+
if error is not None:
|
|
1108
|
+
return error
|
|
1109
|
+
|
|
1110
|
+
try:
|
|
1111
|
+
return analyze_request(request)
|
|
1112
|
+
except Exception as unexpected: # noqa: BLE001 — döngü yaşamaya devam eder
|
|
1113
|
+
log(f"beklenmeyen analiz hatası: {unexpected!r}")
|
|
1114
|
+
return error_response(
|
|
1115
|
+
request["id"],
|
|
1116
|
+
"INTERNAL_ERROR",
|
|
1117
|
+
f"analiz beklenmeyen bir hatayla karşılaştı: {type(unexpected).__name__}",
|
|
1118
|
+
)
|
|
1119
|
+
|
|
1120
|
+
|
|
1121
|
+
def write_response(stdout_buf: Any, response: Dict[str, Any]) -> None:
|
|
1122
|
+
line = json.dumps(response, ensure_ascii=False, separators=(",", ":")) + "\n"
|
|
1123
|
+
stdout_buf.write(line.encode("utf-8"))
|
|
1124
|
+
stdout_buf.flush()
|
|
1125
|
+
|
|
1126
|
+
|
|
1127
|
+
def read_line(stream: Any) -> Tuple[Optional[bytes], bool, bool]:
|
|
1128
|
+
"""(satır, sınır_aşıldı, eof) döner. Aşan satır DISCARD edilir (yanıt yine yazılır)."""
|
|
1129
|
+
cap = MAX_REQUEST_LINE_BYTES + 1
|
|
1130
|
+
chunk = stream.readline(cap)
|
|
1131
|
+
if not chunk:
|
|
1132
|
+
return None, False, True
|
|
1133
|
+
if chunk.endswith(b"\n"):
|
|
1134
|
+
return chunk[:-1], False, False
|
|
1135
|
+
if len(chunk) > MAX_REQUEST_LINE_BYTES:
|
|
1136
|
+
while True:
|
|
1137
|
+
rest = stream.readline(cap)
|
|
1138
|
+
if not rest or rest.endswith(b"\n"):
|
|
1139
|
+
break
|
|
1140
|
+
return None, True, False
|
|
1141
|
+
return chunk, False, False # EOF'ta \n'siz son satır
|
|
1142
|
+
|
|
1143
|
+
|
|
1144
|
+
def main() -> int:
|
|
1145
|
+
stdin_buf = sys.stdin.buffer
|
|
1146
|
+
stdout_buf = sys.stdout.buffer
|
|
1147
|
+
|
|
1148
|
+
log(f"worker başladı — protokol v{PROTOCOL_VERSION}, analyzer {ANALYZER_ID} v{ANALYZER_VERSION}")
|
|
1149
|
+
|
|
1150
|
+
try:
|
|
1151
|
+
while True:
|
|
1152
|
+
line, exceeded, eof = read_line(stdin_buf)
|
|
1153
|
+
if exceeded:
|
|
1154
|
+
write_response(
|
|
1155
|
+
stdout_buf,
|
|
1156
|
+
error_response(
|
|
1157
|
+
None,
|
|
1158
|
+
"LIMIT_EXCEEDED",
|
|
1159
|
+
f"istek satırı {MAX_REQUEST_LINE_BYTES} bayt sınırını aştı; satır atlandı",
|
|
1160
|
+
),
|
|
1161
|
+
)
|
|
1162
|
+
log("istek satırı sınırı aşıldı — satır atlandı")
|
|
1163
|
+
continue
|
|
1164
|
+
if line is None or eof:
|
|
1165
|
+
break # EOF
|
|
1166
|
+
if not line.strip():
|
|
1167
|
+
continue # boş satır sessizce atlanır (mesaj tek satır JSON)
|
|
1168
|
+
|
|
1169
|
+
try:
|
|
1170
|
+
text = line.decode("utf-8")
|
|
1171
|
+
except UnicodeDecodeError as error:
|
|
1172
|
+
write_response(
|
|
1173
|
+
stdout_buf,
|
|
1174
|
+
error_response(None, "INVALID_ARGUMENT", f"satır UTF-8 değil: {error}"),
|
|
1175
|
+
)
|
|
1176
|
+
continue
|
|
1177
|
+
|
|
1178
|
+
response = handle_line(text)
|
|
1179
|
+
write_response(stdout_buf, response)
|
|
1180
|
+
log(f"istek işlendi: id={describe_id(response.get('id'))} status={response.get('status')}")
|
|
1181
|
+
except (BrokenPipeError, OSError) as error:
|
|
1182
|
+
log(f"kablo hatası, worker sonlanıyor: {error}")
|
|
1183
|
+
return 1
|
|
1184
|
+
|
|
1185
|
+
log("EOF — worker normal biçimde sonlanıyor")
|
|
1186
|
+
return 0
|
|
1187
|
+
|
|
1188
|
+
|
|
1189
|
+
if __name__ == "__main__":
|
|
1190
|
+
sys.exit(main())
|