This is page 325 of 326. Use http://codebase.md/tosin2013/mcp-adr-analysis-server?lines=false&page={x} to view the full context.
# Directory Structure
```
├── .commitlintrc.json
├── .editorconfig
├── .eslintrc.json
├── .github
│ ├── AUTO-RELEASE-GUIDE.md
│ ├── auto-release.config.json
│ ├── dependabot.yml
│ ├── release-drafter.yml
│ └── workflows
│ ├── ai-release-notes.yml
│ ├── auto-release-on-merge.yml
│ ├── build.yml
│ ├── codeql-analysis.yml
│ ├── dependabot-auto-release.yml
│ ├── dependencies.yml
│ ├── deploy-docusaurus.yml
│ ├── lint.yml
│ ├── publish.yml
│ ├── release-drafter.yml
│ ├── security-scanning.yml
│ ├── test.yml
│ └── update-dashboard.yml
├── .gitignore
├── .gitleaks.toml
├── .husky
│ ├── pre-commit
│ └── pre-push
├── .npm-cache
│ ├── _cacache
│ │ ├── content-v2
│ │ │ └── sha512
│ │ │ ├── 03
│ │ │ │ └── aa
│ │ │ │ └── 7fa6effa7f205c0354d1cff1aa5983d58a996b7ed716da0642f6aefd9e0342280791fd7de070475740797828d5d5fb7c20209d423e4250dc81ccea572cc8
│ │ │ ├── 04
│ │ │ │ └── 72
│ │ │ │ └── 7f10aaee348a897ff41a86fc704195caca0390db9ea6c9e37f130f931dc01ae6af8f8f24d330c78d402e03670e40c1fbde96c52b03a07aecd28ca970dbcd
│ │ │ ├── 05
│ │ │ │ └── 1e
│ │ │ │ └── 43b4d472f80b30589102c80d7baa1503bebac267acd73827e4418e734a66fde815546e9540bf4dd6a5c8dcc2d0b088b6c800dc7781e6c739c5d89f5107a3
│ │ │ ├── 06
│ │ │ │ ├── 36
│ │ │ │ │ └── ac5238b13c5752f8d2a4ca9732c8de4f9a0f373a5b2dd3e73abc6a2fd1d8b04c4a3a9a076a551ea1c5c12016e87842b02ced173ef4ab8627d4d50a3d19ce
│ │ │ │ └── ce
│ │ │ │ └── 31fb3fed118c646f6e00945cceb9a34fecdd5adcad388f7f5669a78f520f94152c7b9705050d2b75271ad435ef9a02ef0076d755fb4a971560ee12af01aa
│ │ │ ├── 07
│ │ │ │ └── 9c
│ │ │ │ └── 64367edfde90cc006ec5f3bb7de4729249d8a6109e6623a81d91a3352eae9898510906396501c4ade6c1218f61a2a89bbd181585d158fc7f4821631e91b3
│ │ │ ├── 0a
│ │ │ │ └── e5
│ │ │ │ └── 1eac2045db1c8aebb0151acc0ca1816a3be8edf3c55498ca5db667c882c91dcdb2d06b3275d5f2f7b2d3a899ac30a2eda148d0b6de8a8b7bab545b939c25
│ │ │ ├── 0c
│ │ │ │ ├── 4b
│ │ │ │ │ └── d5d99176af6ffadd5fad2bc850beb4766469f5d2cac76d7be24e572fecaa73c3c8d688d4ea6d58233b7218f11c6bace505f153cc410172b18618bf4619c7
│ │ │ │ └── f7
│ │ │ │ └── b9a5515a02c8a749a57a42343a81d89e7560dc4426d4ba241f41adb099657bfb10bd6c6ba5188f3e4dd466a059003da05793c0ab01b9e56362129e2278ed
│ │ │ ├── 0d
│ │ │ │ ├── 45
│ │ │ │ │ └── 89af7f942e9e335e6a25fd266415fdc91ac4bdfd222ff98dd1b7ddff5233e90e99250797f57abe0edcf3886d4b9427715782ab5ed90ed2ad4eb302ac24f3
│ │ │ │ ├── 6b
│ │ │ │ │ └── 4980e8d959c39aa171daa68623bfec5c3d968e5d78a0d9d2773930f4d67dd7e0916e81dbf5740ca364b6e316d1866355a0a728d2f4ab857acfe89a0fbc3d
│ │ │ │ ├── a8
│ │ │ │ │ └── 60c4a2eb1b2e30279d36798085e5e115a314910a1d1d21efb968601a78bfac7b2cca627390009fa368b3d36ef75f0f53bb7ab05a745704f5440c96bb70e2
│ │ │ │ └── c4
│ │ │ │ └── 630c2ba32bf90293f7147bc5f3f194a99bc992de634da6d6be8c6080e944840df92d94dbe6d7e22e67d7937036cd938d411f0a471de5be37594a0b3e333b
│ │ │ ├── 0e
│ │ │ │ └── 84
│ │ │ │ └── ba988a9e094e474eedc514f9cc47bab77688bad0caf4ecd3b9661705bc3adc6f0a83799741b7753ef2ac98f307f4b80126e8caa67cdd487afd1facf842d5
│ │ │ ├── 11
│ │ │ │ └── 3c
│ │ │ │ └── d5f5465209faebee25f63e9010bca5a554329ecb0d2da692e3f85001c26a19be9576bd25986d6d89965521d8cf21826a95862f6846645a97866ddaebc8f7
│ │ │ ├── 13
│ │ │ │ └── fe
│ │ │ │ └── 41ffc9210c7229cb80999a03c1c4ea99e9c57b3bad67b57950b352fd0d5e2c8599a3dac95f26e215279550e4c24123b4bf4164476ce6d5eea9277a2ce45e
│ │ │ ├── 14
│ │ │ │ └── 98
│ │ │ │ └── 584680da89ab5f12450af072a589c9aeff7486143e75ab78ad2831a8493cac4090677ce7315391b19e113513ab2807be8c6d3d0c06d9ca26e5f2031fbde9
│ │ │ ├── 15
│ │ │ │ ├── d5
│ │ │ │ │ └── 9bc5ffd5b08ba922af15c5bede73eff1e4e91ea1fe37ecfd69c1b77566679c911d4211fb42c58b3967095cd58dcbc24f20436f4130241e1de1468365610d
│ │ │ │ ├── e7
│ │ │ │ │ └── 70d1a66f921ca7a0f625039597acc080326fa7496759b7a973250ece93c4ba43e56c1e61e94569dd55127c05ed196e47cf7392d1607fb95ebcd770478b45
│ │ │ │ └── f2
│ │ │ │ └── a8e7b707e5e9518303c730748c6ee0a0140aac2c0c1c360e3a7e09c3973c78a2d38f23929df83daee2fe7aea3568f9a19705d2f5ce53d3a701c0498f3264
│ │ │ ├── 16
│ │ │ │ ├── 1f
│ │ │ │ │ └── 6b18dd0ca08e191543727c554d538cbd2d4cfddeef7fd0afb22e00366f04688f133c254d43cafbcc05a6e764f060316444009bd4da38d5ceaf8bac552097
│ │ │ │ ├── 40
│ │ │ │ │ └── 4cc03faa6c641e32ed5c3879ee181eb1e32ccf8e1a3c6a9e56b5b109dbaba6860a955db85e90a5103be85910bd6f53dd9adf01f0769d0701ca80505e620e
│ │ │ │ ├── 76
│ │ │ │ │ └── 62b03e9b3ac2ad016d1c2e26de5d25f280e9f820e5333eb411c7320ad87d8fd403b83797bb1f53c0ae988397e083c5a2c30338d5f551502047d079ad6620
│ │ │ │ └── 90
│ │ │ │ └── c3f63e1e16b74a41b3552260bcd4e17f30731bcbc70d5170b5b885b1514c6949190b345113994f940dd20289e16008cca66d9f36df967a08025e6ddc15d7
│ │ │ ├── 17
│ │ │ │ ├── a7
│ │ │ │ │ └── a82deef4e79206e8790cdfaf87f07ccfde91a8387651bafd6d2097ee237b48abea1f9d4c29dbfbf95578912441b579fa6312bc2cf178543fe8a663fecb7e
│ │ │ │ └── e3
│ │ │ │ └── 35b4b84efa695068e5aca44f16b2d83ecfa3f0c7045df2843c21771e5b3f7691f0266a54d17f4123ae8b907a8ed0b2c10f7c29f4e41e0886cd4af5643fef
│ │ │ ├── 18
│ │ │ │ ├── 17
│ │ │ │ │ └── 2c6f66933d8224db098964aaebb84a14c275ad10bda78ae0d6066b062e3f676c3acc3457d01605912d328043e2b8af2affafa904fb4205724e71d0189edd
│ │ │ │ └── cc
│ │ │ │ └── 46c566c580d2b56df24eb14f496c62d30cc42ea9879071b0028c9404d1cca53c7f27e7b05b92922605872b322b7e9109391143c39757ff9cee0c5ee96bd4
│ │ │ ├── 1c
│ │ │ │ └── fc
│ │ │ │ └── 29188ce4976f265b266a1b9da38aa0c9d76c1a3f5d4f6b5946a22c9490812e30b04fd2878afc2f3d7ac6d7af1b24cb9c1eedd7ddf14e7c9e6d128005a957
│ │ │ ├── 1d
│ │ │ │ └── 38
│ │ │ │ └── 605604f39c56109b865b34b66e0bfeb2f6b04d676074fbc378d1983d84cf2c58603121897c729da17ba39321fc7831535a0670947ab1bc2b11455a98dbc8
│ │ │ ├── 1e
│ │ │ │ └── 93
│ │ │ │ └── 21f3ea1a86621d3ae4b968528a63a3f2a20f8535a655fd7c893aaedbe18170b051dee7261f75b21a948e24def5369d20ea97b62c92652c787b11ac9a883c
│ │ │ ├── 1f
│ │ │ │ └── 1b
│ │ │ │ └── e177266c2b98bff3d459b4e608fa2437800ac9b4dd6e69f1b8cde4c8435319f627ca5417a0c62131c11ab8ddab308c01bbcdded77501b31478037d52a2c4
│ │ │ ├── 20
│ │ │ │ └── de
│ │ │ │ └── b0e0f4f8d27d6a4f04764ae0520cf3dd978c855f06065f84e0e7591f6e4fb14688f083a26c0ab279d66799273bce2f96abdf74c0a9d6db9b290a7443aaa6
│ │ │ ├── 21
│ │ │ │ └── c8
│ │ │ │ └── 4d7fa74de2d1e8305227ffb384f0b599d7d63aabfebb0667fabe719112ff1149b0556fd2cf27111c9f0adcc17ea2c52bda886a2898052fbb8612c57ad583
│ │ │ ├── 22
│ │ │ │ ├── 5d
│ │ │ │ │ └── 3e6e813bc3f5de6d41f2063ae813e0db072391191f4a2a6213cdb47b3324386a4a4e4583ff6666e102bd031bb466981aa83a765dcb6425bda8c9d90039f6
│ │ │ │ └── df
│ │ │ │ └── bd43e119bfcdc65fadc88ec5d0e51220fc5160d3683f632fbe344309e1ee65344c0125a61caa86902199070998d5fa2046a296ce310a76bda954f2ab7ecc
│ │ │ ├── 23
│ │ │ │ └── 7d
│ │ │ │ └── 11c9d3be6e79f63d0cedbe8db9b6cc0f1fec050637a1546b666a0914efcc8c7704f055fd76c2700e17e01e3fc4b637cc43fb950f6c686451f3f2bd3fa6c1
│ │ │ ├── 24
│ │ │ │ ├── 6e
│ │ │ │ │ └── 701d2dbef953d94fc775ac26e8374d60c74e5e221e452dab052146a41e5b65eaa638e4bba6b2be1ff23951e04fd0d7e3481dc3290517fc4f227d48d0063f
│ │ │ │ └── 91
│ │ │ │ └── 3565ad4d45f0f351efc14f7d18e388db111fd7528201d413f939472e5a090b71720982f2cd78636067b5fdb154787e13b0198bd5a97b086d7db432edb8c0
│ │ │ ├── 25
│ │ │ │ └── 31
│ │ │ │ └── 7df54ffa5c88c2068d30aa4539b0ad7482561edbb31146c7f0a22ab9cf338464b1d4dc0dca08c6b95ff6b37a4611089d0797023472b0174bfe5d1074f30e
│ │ │ ├── 27
│ │ │ │ ├── ba
│ │ │ │ │ └── 7ade1462023c35343130c355bb8b7efe07222b3963b95d0400cd9dd539c2f43cdc9bc297e657f374e73140cf043d512c84717eaddd43be2b96aa0503881f
│ │ │ │ └── cc
│ │ │ │ └── 7ff9f02546d7f9b76029a3c43c960234a1c7afcecf2b1219560c52a7796787359a0657587250b34bf3167b668259f47ba5b7bc63a8c09f7e808103fc5901
│ │ │ ├── 28
│ │ │ │ ├── 5a
│ │ │ │ │ └── 94f127c3ab2e4cf2543dcf54148bba1a2436a0fdb2befabecbbdd43c121d33494a8b14a0f401b1362d03d6063c01f93a0b7c5039ddfe45671cbbd31e006c
│ │ │ │ └── 86
│ │ │ │ └── 0b08226085f1d9c6a8d8044eeb132d0e06e4dde710874bbb47560bc22e4c7b4ad2286b1c0d5b784200b80452315f79193e306fd0c66a7fbed113105ded44
│ │ │ ├── 29
│ │ │ │ ├── af
│ │ │ │ │ └── bd4ebbadbfb1bc33a593e927a2456cfbf762b9a84a881841b35ca84013ac4e58063aa4f1fc53ef48637a0232fea4a9398bb2fed787fdb0d918a091e3ccb2
│ │ │ │ └── b9
│ │ │ │ └── b63de994402dfb4aa2bebf8c8c4e7f85ef10a2d1432f36a3fcc355a9b86f1d6c7a1d23df0f9cf31de30cf4450d8a753e0592af3c5c5d2740953da44fad5d
│ │ │ ├── 2b
│ │ │ │ └── c4
│ │ │ │ └── 318a283459760f3737be2a0420bf3bd97864683ea1b7d5e3552be33ccd92d13186a76151c06c0426cd1a9b440c2310ccbe2812d7bdd5a1189a3054915f04
│ │ │ ├── 2f
│ │ │ │ └── 43
│ │ │ │ └── aba62f2a1a9446fff35df87f74bc507ede21e7b9ed734921a634e38287518b27bad4295c15d87be28e9846412d949a15197b04bd560bf1608760afe7c6d4
│ │ │ ├── 32
│ │ │ │ ├── 42
│ │ │ │ │ └── 82c319574e0cfa085a09c77a42c27d3b18aa77ebe699caefeed8b9f656b0390dc7720999004840c14ddf31e708534102f90a261fe29ad728b72041dbf6f6
│ │ │ │ ├── 50
│ │ │ │ │ └── a0bf72bb8f50802b1bc27dcdcbb2b57cdcfc7bbb7a08fd31f5b0c86082afbed10fa778ad4970f5dd0917df0c0680c1f9ddcf6af8948357afa9178ccbe6c4
│ │ │ │ ├── 95
│ │ │ │ │ └── 043763a876d533c6f29097bd9c505ed14391221ec1af4ac546d226bd73945b5862f6088e02ec4a4f4bc513048a659e5cd988db95e7ac3e16e371cb7b72d9
│ │ │ │ └── fe
│ │ │ │ └── d03dc4f0f2db74f9cdcce912a7b1e396ece6a35e14ecbb79361548bf368e5efa879c26b1794557b4796dc917d1ce9eead2d58df006ed72fa7db186976806
│ │ │ ├── 35
│ │ │ │ └── 64
│ │ │ │ └── 36ff779dce8c7028d4aa782f582b6ea57d5f3314ae9c284778255b682c3024b33a7516328f5df85e55ab35fa0239880111b0ea824e974922956f42a65f18
│ │ │ ├── 36
│ │ │ │ └── a7
│ │ │ │ └── 29fade5c4c1f018a71646605e23099e2407d0fb14b76939d455216dd7de2af738002706dae427898ffcfa1d58bfa2b36b843b943ecf415d33d2889c13432
│ │ │ ├── 37
│ │ │ │ └── e3
│ │ │ │ └── 1e5d8a2aaf7a4e827f317f244f44437b8076a42d88e1b07856193ddf58088be08900b74883c35e108a2126d9b137d1ce575f9ab416d000dc22b97fdfc152
│ │ │ ├── 38
│ │ │ │ └── e7
│ │ │ │ └── 210e087817609c84e5fde1c455aa1bf2edbdc015bfbfad05f2b309b39866a445f90c8285958df9cb5a4462adf2c47ee0f8cac556d7a797cf0b778c723328
│ │ │ ├── 39
│ │ │ │ └── b9
│ │ │ │ └── a7205e215cd83506a8671e681b0c44c5f1d2cf0a08195818e441f859a5bb3366762eaf90d49634dc0878a2e4b0b7279134c9e3bfd4b20cc87f94bc7420cb
│ │ │ ├── 3a
│ │ │ │ └── a9
│ │ │ │ └── 4b2189b9033e8e0452f291bf1628d8a260a95c48549720363efa716f86c7a0b0ce583f321496abdf76a10a5ae3c37b4b158a6ae3b60487d43a3f2dc91979
│ │ │ ├── 3c
│ │ │ │ └── 42
│ │ │ │ └── 06098e6d4a552de7472ac8c5df0b35fea0e3ea374bee1aa5b36dc276c6f9e4ce4ab8ea83a9cfb7506930c175f2026f8375e3e1804540f0d97576378b6fce
│ │ │ ├── 3d
│ │ │ │ ├── 70
│ │ │ │ │ └── 9e407e6f3f59d8bf9189580edf77bce75b0d73d1eaae1ea7f0c20e364f8f0fa94d555a9a24e394123b4417de5981f73d033b4512e2756c93bb197a62d026
│ │ │ │ └── f1
│ │ │ │ └── 792d00bfabe4a782198843daef29cf196e00d6be6021d201339cc4dff8375656be6fd60ee482860da519ccbdda237852e681b925604272bb81d8d6f4257c
│ │ │ ├── 3f
│ │ │ │ └── e5
│ │ │ │ └── 6ed6a5dfcde7628ab987382df1286018799b4f715f60efa5fec60d850f8b58811ef57b0300df9637b02cf7ce188dfddc1e7d1a495f4c81720c22d5f5cd40
│ │ │ ├── 40
│ │ │ │ └── 6c
│ │ │ │ └── 5d5813cf17bfca0a5e9bc1958f2a9dcb625db6c63d171adcb4846a4f33b0a08a831263cdf57fbfa19f97a06866a6aedab04b56eee9f213f453da1fe24f3c
│ │ │ ├── 41
│ │ │ │ └── 36
│ │ │ │ └── 2e0deb12d15b6e1cd36f321f828e5289e0b26272408c500aa3944dfe8fcc3e465469c325f76a91102861736d919da3b5cd1b5b576be6d0a8813b1c85d3db
│ │ │ ├── 42
│ │ │ │ └── 9f
│ │ │ │ └── 166d93817be6e5829b944fe970db185e2cff2ad286ad73d5299a27a61080b11af14b6261e6f50a30559187b499466d2e80eb227789589a77fd9c5639ce88
│ │ │ ├── 43
│ │ │ │ └── 46
│ │ │ │ └── b3719a32898bc593e5539cc01a560fbb1f2e869f334b88933568e90365a6817382299f68b60d5533d4631c22fb0bb778f3473fea6ca5e4a0fa752e1a66ba
│ │ │ ├── 45
│ │ │ │ └── b2
│ │ │ │ └── 514b85164059331d34f057298c4d4bfc12a6213a9f1d38ebe22e3dae82d4e25d1691412ec62c6c594cb2f58d684c7a84827f9ce671992a4e5f488987d771
│ │ │ ├── 47
│ │ │ │ └── 96
│ │ │ │ └── 71f6670946a78202c3ff887c52b9e731adf421cb47d1a5282140115de89f3a26448a89769a3059920fa60903de08c132f78ce0990db0b1eb376340ad1d6d
│ │ │ ├── 4b
│ │ │ │ └── b3
│ │ │ │ └── 88f6f6507f3628937e2977e64b60c8827c40969944b9fc4872e672a4c1f1af2c8c5088ebc1c912b8d3b98ae381869d5b789210d4c5ce3976fc52e02c6f36
│ │ │ ├── 4c
│ │ │ │ └── 28
│ │ │ │ └── 25551b7395f7d137144c132477e831812c9a5ebac15c80c543f4f644cc02a752cd65282817e6ef41982d9883e2cbf4c8190ee80516cd5597e269e2dfcf1b
│ │ │ ├── 50
│ │ │ │ └── e4
│ │ │ │ └── a1b0fc33ecdacc52a851eadd215a315dbaf3b36edbfbb680c7d7f848adf44d2030679c159dd02c094c6bd3a67815966c0609d3fdfd997fb55ac3a9cb98cd
│ │ │ ├── 51
│ │ │ │ └── c5
│ │ │ │ └── 5f55f68ae127389bb5f77544a81e8a3340604415e0c2fb3568d3ab7df317bc0b31d265905e90d5c7fadbb435a947a25709fd0006a92e3a1de7fb41704833
│ │ │ ├── 52
│ │ │ │ └── a9
│ │ │ │ └── 3e82c7f2c883d4ae09b0914cd26570a6eb14a5630f94eaff12e10cd6a445b42447a99e88451a3ec2585462a33a0df5de21124cecadbcace20fc819ef6f24
│ │ │ ├── 53
│ │ │ │ ├── 1e
│ │ │ │ │ └── 328065acbb673b8ac1567bc62ed5896e266a95871a8ad9c2d735003901c0b741f6c636933b7eed18f1bff3d7aa572e7171658bd685dddf84163d0cb982e9
│ │ │ │ └── 67
│ │ │ │ └── 3524cf804eb4a5a184fd2a5cb1c74ff43800a3b0b150bff1e03d9b5c17b20da7ccc388c7b4370b9f56d1a4fb68322457012d332d0f98728b420a950195db
│ │ │ ├── 54
│ │ │ │ └── 76
│ │ │ │ └── f38d9361ee93db65ec9e436476815c59fa45ad7ba18f8d2784b84e42a140d509f482d9bd8985073bcb5e2dd7695ae91e0d118e2b5d51c1f9a50dfa4209c5
│ │ │ ├── 56
│ │ │ │ └── cb
│ │ │ │ └── fb9056979bea6d1c3319ee2cda46c3fbd0682b5bd341346b30b7d39969504b944d123690eaf1ebbf5465f217dafb3346b32b75b2ece9585ecbb260b1731e
│ │ │ ├── 58
│ │ │ │ └── 42
│ │ │ │ └── e747c96d01e41476955b36960cdedd5179094ccd826e3c32a65468132a18f093f6db9655401ad49693f38cdbc20d31d5f978e8a69476ddea6b767c28d38e
│ │ │ ├── 59
│ │ │ │ ├── 01
│ │ │ │ │ └── 3c1d8e5428225103af34c913eae58ea0145d6932ee45bbf5014bef3d76912a96fcfe1006fa88d749cc57d159304cb378a7d177c01699fdac050cb048ff74
│ │ │ │ └── 8f
│ │ │ │ └── f74d4304d31dca3d875147110926f5d11d5e0fc8fa14b31b596bbf25c08b7045044785dd94f713ac71a4ff6137fcb825c8023789385055121ffb16d0fc5e
│ │ │ ├── 5f
│ │ │ │ └── 11
│ │ │ │ └── 407da4bcd54592ed39c7394f97f3b2fb205152456ead1fd34f89b2645e365d41703af669ef2540da0d08c99e450563440dac5d917f71eae214069883e9b1
│ │ │ ├── 61
│ │ │ │ └── 3d
│ │ │ │ └── 46a8f48bf24267db47637a5317eff713469fd8f70e48647bdfc504d51eb3aa6b6c8c97b8bf51f32a29153957b984c8a4eb5158095e13503d5086f0f04ba1
│ │ │ ├── 62
│ │ │ │ ├── 00
│ │ │ │ │ └── 697491cfc90d94139c7e8654977277a3cc0bc3d1bdb65363ae00ffbc3a79494fe3e358fc6d8261aa28a73e4604cceb753d80dd18ceb61cef5476593fe14c
│ │ │ │ └── 5c
│ │ │ │ └── 559b200fce09df6b6d7d026e684db52cfed15974235f7ee9b98206b82334f452e29f9e014f64e554b3aa61020003ec3bc31df28911e4b58c3e60efce4577
│ │ │ ├── 64
│ │ │ │ └── 19
│ │ │ │ └── a11350bd2dc3e81fd5d949dc223ed6cf1d944ec009cccbe90815056b9cc0b16380ae765cf78013a9ce29607348ce8116a24f7b0859fa4ca265b66abda8ad
│ │ │ ├── 68
│ │ │ │ ├── 64
│ │ │ │ │ └── f16e96e0f3f6f925f5351d74ab6c7df05d9b8b3c970d11c65014cc4bb37a12ce0b55bba9c53e46db18652f05c523295d98c81f56c7169ba3e1c41fdb5c45
│ │ │ │ └── c5
│ │ │ │ └── 933533de497fc54cbd70cd6feb0b322bac19a5400a287def6dcf6da202936e4d5adebd8d659df4e6ff66c732eb11074d53cd8357ae000135570a67d2f1b7
│ │ │ ├── 69
│ │ │ │ └── e3
│ │ │ │ └── 661e70716e2d92b746aee950550bb25716584b94e9ef20895e3cd9e2c943400a5ce6b4050463cfe90622b78878ee7ce97003e736d3ff239e0a3bc5cae0f0
│ │ │ ├── 6a
│ │ │ │ ├── 61
│ │ │ │ │ └── 84cabafdddcaf7f155acaf643b8e274cf2b3b0f6d4e3f2b3966012d50d977b74abcf00e70cd30d7e604cffd62539a3825d5075b7190dda35e960c0c092ff
│ │ │ │ └── 6a
│ │ │ │ └── 5357458344d33ab7d8a6c73b040d35996b0669cdf7100c5a0f6f2b6eb79633dccea6546372802233aecff1d2f8fb786751c173855c3e057ddcc36f9471da
│ │ │ ├── 6c
│ │ │ │ └── 1c
│ │ │ │ └── b3af5f9ea75ce4e15b9b784555895e7ddafbb69471360596393a7cde859a8e3a0a2037cd3e98db42a8f9219f6824949a8ea715a03e86134a78410aaa4e5d
│ │ │ ├── 6e
│ │ │ │ ├── 92
│ │ │ │ │ └── 31bead3789fe943705d9f874caef524b87800fbe75e7b4373a5ce5fc515ab85d039597b970a24d00bc897e6fcce00b0ddf49a55364ca403cf6a05db2a61d
│ │ │ │ └── e7
│ │ │ │ └── b01f332f60bdbd8dd7904d520b79c49a64a9edfd12568e8642179396eb467aeff1a648b06438533baa1d4f237cc536d25b6992f9790bb5bcb7daccec23e2
│ │ │ ├── 6f
│ │ │ │ └── a8
│ │ │ │ └── d2bf1bd59f2a6d0222e36e458b13f94e9d1e257d3b43025f9e502ed1672f9041673ac11cc8576084eb106e3260f1736a888a1b430990f934f38597b7d105
│ │ │ ├── 70
│ │ │ │ └── f1
│ │ │ │ └── 8d93b90989f0ea548b6fee279cc7109402a57c6d1c0466f79c2f19c2e8f4579e1a83507bf35f7ef365bc35cbc4d80a80ec4f9c3b0613e85884fcee89f2fe
│ │ │ ├── 72
│ │ │ │ └── a7
│ │ │ │ └── 9fb91b21d76a56c86b08a0128903d96e16ede6471080f8e459bc0e24b4b4b322e094b56571188b978a01303b9ff2c1614c67640418a5af9191b5cc33136a
│ │ │ ├── 74
│ │ │ │ └── d0
│ │ │ │ └── 2fb0045ff1cb4285d2d1716050b44ab3155593ae35372fabc4d5ad65d2240e88fa417fbf25e754d5f01cce0b1b10b94de1db3ae6db536dec534b31fe7771
│ │ │ ├── 75
│ │ │ │ ├── 10
│ │ │ │ │ └── 7bf2cacdfe5ea0a96ba56a1f52af17989f179d7481b7d3e18ea8affd3a52d5c8b8371cf9ebe92a8e59358e5ca4700b6786602919e7d34db9282f4aba6038
│ │ │ │ ├── a3
│ │ │ │ │ └── a3f7440c563aba907ae0516c81759a218da2b906da1989ec63393ec9b20606733d03c27756cf1662a0525a68327d5efde0804d2937381f608cfcc872f800
│ │ │ │ └── c2
│ │ │ │ └── 855f78e7d0ca486978e2b2846f7b12095442b36aaef3dab64ac5ff8c4abf5391d9879ac5389b695c2e88eb8ff14797c9a4e55c4c99803e7ed4643ffde829
│ │ │ ├── 76
│ │ │ │ └── 12
│ │ │ │ └── 9ff74dd4fcf41963a6e834db4019d59b1bce5601b8d3ff5c58a19202ec5018d3259aa4e05056c56b0e5e7c5bcebffded55a4c341b5157831a5df74cc9214
│ │ │ ├── 77
│ │ │ │ ├── 62
│ │ │ │ │ └── 562c28af999613488a207bd32c805099aede7bd418a47161989230b59219656d3783946a99d83f2f0fc13f9496bc58659b6fb3e59bcfd725857b2091d967
│ │ │ │ └── 97
│ │ │ │ └── 4b4ed1a5c47e3b8cfe73cd5529ab55029854420395ff865b9735647a32741aa3ff3502cd830ba2df80b1bdee0aa454c8bb96de2db8f016f005b47b479357
│ │ │ ├── 78
│ │ │ │ └── c0
│ │ │ │ └── 6b11b047b69af1116cdc8c7416a1601f7402d3acda0d1bbbde0aa3dec9b8a3e7e9e626c78a8e7787d83316de4dc12ccd9b73053f7beb7a485de0d521975b
│ │ │ ├── 79
│ │ │ │ ├── 7d
│ │ │ │ │ └── b6e1fca9606766d0dde9da715c03323e25af187d1cfbcf8495257703bdb476d278f0aae4bbc55483ad6db2767f1381b31619e334c12071e1d137366b7b2e
│ │ │ │ └── 89
│ │ │ │ └── b441606d52b0566561b4777f3a386030d7a67df793e2395a3607b6e35926c779d1a5e5ed1959aabae6438681448d7ac1080e407d2126d383f24af5d84264
│ │ │ ├── 7a
│ │ │ │ └── 58
│ │ │ │ └── dc8040e5127b3fec05c5a2c0792bfda708ce0fec540f90673f0d62f2e6b985116bd96b21ab8a4d5df7f4086399c9e1ff58b15bc1900ea42691e7f6b21275
│ │ │ ├── 7b
│ │ │ │ ├── 0a
│ │ │ │ │ └── d74434c0a805e5925eadfdf91758d021157f48f8290a970eb38c4c24f3a4523cac19af7c69051b28eb9e5aa9869fc2d9dba472e3eada05ce677ac5d569b5
│ │ │ │ └── 82
│ │ │ │ └── 092aa37cb3662a311779faa568fb5378b34db475209553248505bbac1d4bffff9f78e6a241a159fde805f205a1d1a978290d0783e32a55f8cf71a357e93f
│ │ │ ├── 7c
│ │ │ │ └── 95
│ │ │ │ └── e3148786596741652419f62b7050f594580fe637e4bd092b38980d4dd6846c59e026e8229584e8b17770b35ad310916bed3729e9d0fc0db589153a3e0b29
│ │ │ ├── 7d
│ │ │ │ ├── 3a
│ │ │ │ │ └── fed3ed3b4eb6ed9e6214fac0edb28d53c3f3a08072b0fbb5f07feb16409c5e200137afaff9f0ab664666d2288c52c18936c0f3f1be80ece3d7bab2b1ae1e
│ │ │ │ └── ea
│ │ │ │ └── bdbede422630fa52908016aa17d4f671f25457aa01d2536ea80bfb35a8e4181420bdef7176655b118af4cf701de6cabce22e2129e1876139552b6a053339
│ │ │ ├── 7e
│ │ │ │ └── c7
│ │ │ │ └── eb3b433157ae199e8cbcfe5d6f5488e31dadbd499cb2a8f8100708620dc696f3025cd96dd7595386c78337a09067bffcdd519208a75803792f7c1b33fc36
│ │ │ ├── 7f
│ │ │ │ ├── 24
│ │ │ │ │ └── 088460e1cdf73da4ada41fa3e5f5ce010c919f3243ea932220603b61c8d628360df0561a0930c875f564b8529ff528c3c556936c4f6ab75a65e7d8dd66ea
│ │ │ │ ├── 41
│ │ │ │ │ └── 45a4875c1e09fccdc3d26dfd5d45ebf0b74e3b60c9da889337bb6c3645ec2b07e7e86ffcde3d972b3b24282cc30eeda04875d2dc40810ae5d62390b9c6ad
│ │ │ │ └── 72
│ │ │ │ └── 9d5113edc958d59fe45617ba62bafb6c0cfc8e074e5fd0fd94df0768ab589726b5d3dcbf315addd14f7e6f4fd37eb139796bf15d7b27a9d3fb25c6f152bb
│ │ │ ├── 80
│ │ │ │ ├── 13
│ │ │ │ │ └── b20a2571ad76a461bb0810cfc3ee5ab35d5d27837b68b7ebba141ab227d0aebc3009ab0f979b11f9f2919bfa1980466cecf60f5319d18e8c6672ee5ce16e
│ │ │ │ └── e2
│ │ │ │ └── 879241f4307f0e5a82afac4d57ac9a294e7152edd7234c37cce8e9991e85f545996c735b8d146092668b171ca3639638f4b661454f0a895195085cf04fde
│ │ │ ├── 81
│ │ │ │ └── 34
│ │ │ │ └── 2159872524c81acd6fe2bfecfa09ae0309057356f3cd16746072e23309de6079f18391e5b666a924ddbd1848ec65924e38b515318909593644389af6a8f2
│ │ │ ├── 82
│ │ │ │ └── 06
│ │ │ │ └── 35fc6a4769192719292c0abf2b072d271c2aff9c6977daed1b00ca945ca4350ec4f88cd6d5c213ac83647a105b42f59605fcd1826144b5ee690a06d17cc6
│ │ │ ├── 84
│ │ │ │ ├── 79
│ │ │ │ │ └── 4d3a41a02d827d4087dcd49a2f9328190acc7549f0033f7d81c2886e36003dbaa4254da63c5adca84d9b69b4fdcc27aaa8ed08d91be06ec61f2855ed6a8b
│ │ │ │ └── b1
│ │ │ │ └── c971ecc90c5fac945891d7d8677fa7178bf6fccc23b853378d0d5209bb8150d0c7e968a5095df5ad6049e82a07d6bdc52cd310f81f211930b9c3e66c742a
│ │ │ ├── 87
│ │ │ │ ├── 51
│ │ │ │ │ └── c8274b42245cfba0f50963b50f4e0c1822647ef67eac0b1f19aef5f2be17651e402f82b24cde8aeddfb34c58b02a07ba6605fbc37f987cd1a4c706c553ed
│ │ │ │ └── 71
│ │ │ │ └── 5b8ac6b69ca18fc42a66f3d1e4df79412ec9da181bdcb50a2968148e5bfb88b3a1537b5013c809ca149af356cf6fa4676c4deef7585dd5e2522c93819a73
│ │ │ ├── 89
│ │ │ │ └── 83
│ │ │ │ └── 4ecc75316bff72be6a6ff571991467ee0999b790cdc344e13b9b699401301382e6f36f484e96b62191c8600c9ef62a15d3f2f7c2800e1b6ffef0db64cf8e
│ │ │ ├── 8a
│ │ │ │ ├── 4d
│ │ │ │ │ └── d9802f5d63f95855533ef8e212b1a6037a0d6d6f456d3f9b8bde8ba1d64a0639a50c0cfa5b1487a2e099058a659414f9fdd2c6cc34c5d000854e96760a24
│ │ │ │ └── 97
│ │ │ │ └── 1f9c6fe9e382d2b35525df2f2f42927626596f77609512fff85ab306c45b554a1645809137769b0f9d225c5dd00ecbfb1208bb9417a6fe6eed3f8ee575d8
│ │ │ ├── 8b
│ │ │ │ └── 24
│ │ │ │ └── 57649cc4cc2d8bfaf6bf56dd7d3ee5000820cbdc9b7a9a8699063ff5b0cc59d283f106057e573a80b237c49f1f7316aad99a7fa500c3467d74720661b904
│ │ │ ├── 8c
│ │ │ │ └── 28
│ │ │ │ └── bf40a50cdabd49bb96b727ae131f60394a9280821d0ba649f2a9d4389ba0c2574c49d871b5c40451c0d18f41f8b548b74b599d4e273e85e0e30104d88624
│ │ │ ├── 8d
│ │ │ │ └── 02
│ │ │ │ └── f79519e871a16dbb7574d094e8633ff8424356b30c628c368254d6518914cedc74032ec76ed59b66214bd5e323e9fabbd69b98f4cb44c6fd2eb572e8a34e
│ │ │ ├── 8f
│ │ │ │ ├── 45
│ │ │ │ │ └── bda0c24c37e625fa1587c9283016b66e926b7cd38cd4f86790f318b07d951687a9f63eb43e5f07d589e09df82b387ee6d19016db83ecd7126329377eef45
│ │ │ │ └── 77
│ │ │ │ └── d52e0bd3a39dbb6a7c98c893864d825b1bebe79d062f1349b99a691cd532be9f1029a6408b3082f4699e1d6e55423681928619be933138654ca4068320e2
│ │ │ ├── 90
│ │ │ │ ├── 0e
│ │ │ │ │ └── 56428355a38b7d94dc769103450b129e065e486db48d065d4cfed2e4c3d5829fe871341016e5087c81d86ceb70899e18c9db3416168a8f24fdac2b5015e4
│ │ │ │ └── 69
│ │ │ │ └── 067a0608750b0e6f85e3b1f33deeb5ec887681c1ca3e84523aea83b8b3d2d4f8f2c00b9a09ee485d395171921b2695ba54a8302f5f0d750a5b973fe8e41e
│ │ │ ├── 91
│ │ │ │ └── 11
│ │ │ │ └── 91670ddb2e5148483060c13480d5330114de89e865837ae6e60c4dc017edfec972fc8535aff2be6b90b6ea6176384633e4fc4cc79c2948df341fd5c1661c
│ │ │ ├── 92
│ │ │ │ └── bd
│ │ │ │ └── 17dbee98cbfbc9ccb60950f09911cf127d071ffb508e16802a6ae266ef8ba6421b5af4cee53491cfed0412def92f7062d051b5a9333c2b5d8c2b633b4728
│ │ │ ├── 94
│ │ │ │ └── 6e
│ │ │ │ └── ccd41785b69a3cbe6733bab9c3cb8311092f5d44d32d9d86157b712c156f3dc877209bed0d1511c6d366687506a1b17ccd1f1fb86fac924ce266825906fe
│ │ │ ├── 95
│ │ │ │ ├── 88
│ │ │ │ │ └── 86f66880d649a434abc280f67605abbb47711d06bfdea32cea11a9429704d0564033bbe4f9d5c883412b9525389f7f29fc9865f553762c9f263680b74248
│ │ │ │ └── cf
│ │ │ │ └── da6a19feb78fd2595fea726ba6623ca62ec59f37710b869995b9416382c391aeeb993d54b0010af2abe1c71af3bf488d8a557dba6f1f849fece133c83c85
│ │ │ ├── 97
│ │ │ │ ├── 2b
│ │ │ │ │ └── b13c6aff59f86b95e9b608bfd472751cd7372a280226043cee918ed8e45ff242235d928ebe7d12debe5c351e03324b0edfeb5d54218e34f04b71452a0add
│ │ │ │ └── 9b
│ │ │ │ └── 930ca6e7be7018e79ca9e2f88256e0094e45700f6042e4f4b7be887dc897ddb413ed3d5f1c7cab977e75d565d9d5a36a2335aab01309f3246a780e66ba06
│ │ │ ├── 98
│ │ │ │ ├── 9a
│ │ │ │ │ └── 68e84545cf186953b6927c75871a5e5f661d07ef805b585fa7c3a0c5be109626fd58145345d8bb858e94e1b66b59937dc1c3d4eb628c1c660dea5c352de7
│ │ │ │ └── ac
│ │ │ │ └── 864ad4b45e218c1f4de4d9f3b6c472c17387abd03684f2342e86b2ad5e72f68852c8c6e8ecce321554dbbecfb4675963f590d69a590ed55a1a6caef56aed
│ │ │ ├── 99
│ │ │ │ └── 98
│ │ │ │ └── 448f12378f9292ce130fc418d98bbf63a156f6d27e8eed850861153c0edcb5e811bad603432cc61b4f94549f2d43e8c48367de701b7ae30eca763af6018a
│ │ │ ├── 9b
│ │ │ │ ├── 3e
│ │ │ │ │ └── f67c86d00bc662f0c2cbed99d6642875488172be12158566b611303af794512f2efbf85a10234e59382d58b563f336d50407396c650a1f409d4af467e88e
│ │ │ │ ├── d6
│ │ │ │ │ └── 15ca4945a64c3bf495423b7131b87e3a97bee25d335e002733b2994ad038333639a7227df838fbdbb1c2c77dc3c1de199a53731445c081b4fd0c6973eade
│ │ │ │ └── d8
│ │ │ │ └── 13c11921cb696f08f7ba409a787771b54d81141e7fc5cc952dabd3231f8e9a9f5c0953e19da060b954ba1ff115fc16dfc3969b21029921b300cb6731c871
│ │ │ ├── a0
│ │ │ │ └── a9
│ │ │ │ └── db845c91217a54b9ecfc881326c846b89db8f820e432ba173fc32f6463bfd654f73020ef5503aebc3eef1190eefed06efa48b44e7b2c3d0a9434eb58b898
│ │ │ ├── a1
│ │ │ │ └── 16
│ │ │ │ └── 42c6790ed2f6bb0d8a2fa3d42ec39ae52b1f8c51fd99266c3eb50ad3f93da11c955666ddd334a871eb7e5d32df2d95fe4b411dc952edc2ec440075d2e4c7
│ │ │ ├── a2
│ │ │ │ └── 81
│ │ │ │ └── e7e49fbe8656a387fddebf50395ed76f90be5bde0d8da3e071dbaffa84d3fe80032b33ce9dc72a6feccd310b2b6c0ff2cb4e3b96afa5f64be198029a2977
│ │ │ ├── a3
│ │ │ │ └── 07
│ │ │ │ └── a03949db85191d4909f468f63cea33e3f1165e5851039ea92a6fdfe71c1a212684a0e979a2c59001a5d077f9627e64ac9808c3c23101d3e903dd678b2360
│ │ │ ├── a4
│ │ │ │ ├── c8
│ │ │ │ │ └── 4e7c50cf8aff6de638c85e41e8b169a44b241bbec80454d933d044476ee2e1d93ffb8f832aaa9cf9db715ef0c558f3d282e9287f41f4b6b0cf928e014373
│ │ │ │ └── d8
│ │ │ │ └── d31dae18a09757cdcfbf9ddfbba4eb2ced665dbc390b2319d6d3458cfe3931794c1bd7d09c8fd0990c0a836ac2b52e4c7a32da40824f2c2e9ad2828e9633
│ │ │ ├── a5
│ │ │ │ └── d9
│ │ │ │ └── d16d0e1c40b653ae71d75bbe980854d13737e87032bb5a41cab0335e2c19e80fdd1b630c2916090388deafd50c7901422926898f1dc9ee2272e2f790c246
│ │ │ ├── a6
│ │ │ │ ├── 45
│ │ │ │ │ └── 2e8a52ed9bc6f424126dd4d7da19cb119632aed03ca6dd744311f5edcc3b07a99242b1ac823c861dbc4ccb33ef1cc3f1b4a158438644851d2e6cc467b931
│ │ │ │ └── 5b
│ │ │ │ └── f44a23e04004f4fcb8c2d0c986b28a3fb1da52e95e13a4e500c4ee09dc39ef9cb2da2279cd87d8625354a51a00a3b11bf49cdf53bd7f69591a959d91fd93
│ │ │ ├── a7
│ │ │ │ ├── 32
│ │ │ │ │ └── 6ad76b4469a221aa36f3a42baffceca9258fc13dabcea1f9be75b69bf8c1cb6a3cb6efbfb594b9ba245706805e5eb2427a9aab868ab857636183ffcbbc52
│ │ │ │ ├── 7f
│ │ │ │ │ └── 3b7e7150102a863fe3f0c7edf01b5ebed441e1c485f1b97a3ac58ab37da80e535b9cde6231a3b7f09c4b2f1b566035d0610bfe0557ac9ae62216f1c01a50
│ │ │ │ └── d8
│ │ │ │ └── ff298663e8ee2d918a19a0a00435a7537ce757a337e6dd8597e213c9e56d4ce61b5be30c4b719c5054fed981c51f78a88f5389a1922dab4dcf5248e83c4c
│ │ │ ├── aa
│ │ │ │ └── 90
│ │ │ │ └── 80bd197db2db8e1ef78ab27ec79dc251befe74d6a21a70acd094effe2f0c5cf7ed2adb02f2bf80dfbedf34fc33e7da9a8e06c25d0e2a205c647df8ebf047
│ │ │ ├── ab
│ │ │ │ ├── 20
│ │ │ │ │ └── 87e36d5840f4b65850f10e37ed7dcd5947958a433573aaca789fd3369108553a8fc1c9a845a143497e5e7c90e70419f43fffbc1e1530e19beb2cf0473183
│ │ │ │ └── 90
│ │ │ │ └── a0dc68efd52e822d9d3b85754d0fdfcbf354308c8deba163bd0d9a25aa2ff3ffa91a4f516c78729887b3f82207b16c569db31b0fcfda64172e02808adf01
│ │ │ ├── ac
│ │ │ │ ├── 1c
│ │ │ │ │ └── 7865a5ac22a0bb027fcfbce2f71d4397d8847e951d782302ffd6e7dc65b329403a8408bddfe2410655ebc3a9e60ba4322b2930e6d32a039078654b548e94
│ │ │ │ ├── 51
│ │ │ │ │ └── e187fe9d41cda368bfed295f36e4ae7ad00117f4fd4cabc1ae41877ea3efc3cb5e620033fcab4d2b81c9906697165c165c9eb06d09c3f255e6bb627c3839
│ │ │ │ └── d5
│ │ │ │ └── 1ada8215399d75d02c07b0f09d6312f36af582cf44d1c5602926e26a7c8ec08371d2d44f9d457f4118c891f13f54ee29cc1f09f193c8a7148fddf9901d61
│ │ │ ├── ad
│ │ │ │ └── 48
│ │ │ │ └── d0a32ede8194fd5d855704ad637bd724067369eeacd164e84b431e51704a767421a55e8fa6bfabdfec09b82e29847050492086734867e04ea73d402acf4b
│ │ │ ├── af
│ │ │ │ └── 39
│ │ │ │ └── 5d2143741ba08238f96ddff36759c58c63b72cb2ace9b9d61da859fad9b26bb3996e4ff4755f8d512979dae21b107a1b67fbf120fa53187890dd08590d35
│ │ │ ├── b0
│ │ │ │ ├── 69
│ │ │ │ │ └── ef6f9766ac968a119f8b0c8a60baf757ddb0e5125966bf8fc2950f5ac1c98266b971e63432c8c58533990123e13234e0830e22a4f22974cdeb97dd9960ff
│ │ │ │ ├── c0
│ │ │ │ │ └── 6287fba94763d8f3bc9319dc82b1dcedef258efaf60c010e7ed197574d26380855104a640b6e1789895d846c1f52d4eb20267e7c0f1fc6687bdb0502bf99
│ │ │ │ ├── c4
│ │ │ │ │ └── 86eae8813cc26b7dfb5c095299e8d9b392c4d3b26e95a0736a0e93e14e5a532b33da47ecb9f8c6756f22a21ea62399d17e15f3c3819ecaa7043faa2e8914
│ │ │ │ └── da
│ │ │ │ └── 8dedbdab711791e11403743c443259923b3cfd3c763ac2b6dac038489319c7af46f4e0247e6e42be79aea56dc8e06bb9181ea26bdf8bfe4ff5e3ceb61c32
│ │ │ ├── b3
│ │ │ │ ├── 1a
│ │ │ │ │ └── 7f56449634bc6e62aad466db2af6562e57fda7258e005182788e3cd7642e657eb8cc865a4aaa3e607779c9076547a315a3328ee124b9c3d889af9f2a814b
│ │ │ │ ├── dc
│ │ │ │ │ └── 2c7145ba3c560a768d1533825be8d86c4f0afbf5ab6f4e664f0cd18f995a035188194d8495b01f2313f3cfdabbe528a40ef97c4127901e9e647b28e19f5a
│ │ │ │ └── eb
│ │ │ │ └── 39f998983a92db61bac89488a0adce33ed82cc1956815b337a97ee86515ad142f4d3d45ad1e332c7c5713591623b4b4017b0fd21eaaabe2843c2c69fbeb9
│ │ │ ├── b4
│ │ │ │ └── fb
│ │ │ │ └── 863930d065d0bb76f5651b3768e84387f4152d72303c3bd9761825cfa8c81d4e2c9c938025b8679f319c4b8d611f9626ba4d029f8475dc6ff586fe5979fd
│ │ │ ├── b5
│ │ │ │ ├── 37
│ │ │ │ │ └── cf317838766ab773d9617270de8511dd367bf7467f2b2288457a4bda388fdd00f3b1dc6a77e57848299423f08c9195f61ce16ae9d89f77798b9bc8cc57dd
│ │ │ │ └── 8e
│ │ │ │ └── ec56dd722fda33231be66ed379aad987da4ad770109f8c488280a18baae9c91ef82f646d8f725da843791b7190116f50461077642f371818ef329d59627a
│ │ │ ├── b6
│ │ │ │ ├── 3c
│ │ │ │ │ └── 0ce5ec4c83a046448fa43664e7b4db2f7594b55fc045612ead9c9da1747d2457133afde559db1cbe16a4ad496bd89ad7c53032c8c6eae8ac7c0329f0f3e5
│ │ │ │ └── 47
│ │ │ │ └── c51185189afee296af509cd342d0b1db64f8e4429ebd9b6a73eb6e59d67b5aa459b73c785beab5152061562876c7b4f09cfd2d913c0d1fa4e78814d23d63
│ │ │ ├── b7
│ │ │ │ ├── 63
│ │ │ │ │ └── 839645c14329fb8e497a4cd6b0fccb55115bc819e9490c21b8d4e92afcac14b090704385d566c1c055490ae2606fddec22012dcf1ae516b98d81a0ae1953
│ │ │ │ └── 85
│ │ │ │ └── 3df3088c6764797e7a179e32a80030fa7cbf022fef63c8c7f3ec5a65aa06d7ca593d705bde0d7b806cf0f7f944fdb66541229b42fe8d10525f7d39c896ce
│ │ │ ├── b8
│ │ │ │ └── 24
│ │ │ │ └── 3c28a65d120aeac2fb2d4de11c5f6593118bb868cbc14a7c4c3c8c10a707a0d9b55ff09e592f29a2f3f2075cf6d3db5a2a9d1edbf4e9dce27ae4e5b903a1
│ │ │ ├── b9
│ │ │ │ └── e1
│ │ │ │ └── 1ea67ba3a6a79eda8e5a2189ef1d4e82d00e3630d76c2037aacb907276b92e0b947566e5059e6dbb11e1491a8107250827dee95e46f9935da2607d76ede2
│ │ │ ├── bb
│ │ │ │ └── cc
│ │ │ │ └── 7c0db6fc0e8b37e0cecdf29e1ee0017ef818b50fe96af9d9110af2e2e50b9bfdd23be59ed84c85c17b30382db2084a5cbe11c9f4e5f7687f3670ab23afa6
│ │ │ ├── bc
│ │ │ │ └── 5b
│ │ │ │ └── f1455b099cabb9d8a6727135517bc28c43a223700d02c2cea588290de796c471d64d7cc6c97b7b6483d75b3fc88fedce342dbef7bafbcd492b7596a3134a
│ │ │ ├── be
│ │ │ │ └── 60
│ │ │ │ └── c3d7e8b035532cd971773988d125be5d9f3a7a698705b0a413fd08f7a91ae9efbbfab450561406f519cbe50fd85e2505f8be0a06dad1cc9e82b0c5a61a1e
│ │ │ ├── bf
│ │ │ │ └── 18
│ │ │ │ └── 54cb827c9727b28a71fb033975a5d778dc6261647fed3f6c1e37c4e7b506e5398f80d176d3f03264d7fa023ee38eca0fc96bbe7bac6d028077160bc39f30
│ │ │ ├── c0
│ │ │ │ ├── 0c
│ │ │ │ │ └── 6be3097ad962bee4229c4963415041ba3e48c57906c8c41a44937e26387be6882937d0d4ecc066ddbb4d152f7b2470c4b1448494dbb0a965e9876f6159f1
│ │ │ │ ├── 16
│ │ │ │ │ └── e9bfe3507ed1c3746f3a41cd292325e4e48477b4cf157749d62ca0dc5fc9cd9f89d714e170b0abaac36a2403fd43fe6a5a0249aeca776b3c94d80cd66d17
│ │ │ │ └── 1f
│ │ │ │ └── 0e75de3b862a4efcce4709d870b00fe43a864938289e23df5d43fe767ff3b8e2581e0eaa4feccf7d226fea861e9fa9f59a0e0470e42d2929412aaca5ae8a
│ │ │ ├── c1
│ │ │ │ ├── 2f
│ │ │ │ │ └── a1020252851d0a844bcf240adfb8f54dd7e1f3d6dd18ea7e632eb1906e46f8bab80f13fd11bdefb590c075bffa16807826e1621c57e8bb176a53563fb689
│ │ │ │ └── ae
│ │ │ │ └── d88f25067cd667808fefb4ad141c037e9600c2c413c2ca55571a9d33bb9f45cf96a21ad3576aadc3848a2fd3adcca2b07e55fb9f2e1dc9945d8a7532b7c6
│ │ │ ├── c5
│ │ │ │ ├── 23
│ │ │ │ │ └── 32519743bdedde63440ebffface305fc949686914dfcc2075cb850df6d2d7e4880f9d2c802eb2a8dc6d157eb74cb4442d5b2280cc8b486369e7e83e7d1bc
│ │ │ │ └── b6
│ │ │ │ └── c21f9742614e53f0b704861ba1ec727cf075ee5b7aac237634cce64529f6441dca5688753f271ce4eb6f41aec69bfe63221d0b62f7030ffbce3944f7b756
│ │ │ ├── c6
│ │ │ │ └── 4a
│ │ │ │ └── 67867eda208dceb36587eb399998dfd962207f9a25345a6c58e4d905c66c7330b2808b28d74afa4d79e91cf4d17769eb04d23d57f905b347b51db9143e02
│ │ │ ├── c7
│ │ │ │ ├── 94
│ │ │ │ │ └── 4bf58da9e7e4a1dc3dfc161f62fe243964af9ee31b9745dfe919b3380f5ded828fcc1b06edb5493c7a6cad72bd58633058b3e6a99d49e00431587e98cfb9
│ │ │ │ └── 9c
│ │ │ │ └── 4fab30e96ea730f3dd6b17884ae570f6a995a64029b6f853539b45c9fb64aa09540c15d496b4035a767b9b922f6c61c05ad88cba5a2e82f1cfa0a26c605a
│ │ │ ├── c9
│ │ │ │ ├── 0f
│ │ │ │ │ └── 42a371464ab760d591f588236bbdb498921141ee5849b2f5dfe4ce0e73fcdf4490c75edbfc83d0ca321b2b502c8ec705d8e66dc9414c5792531d550ebe2d
│ │ │ │ └── b0
│ │ │ │ └── 7244d7a1418095d97556fee24a89d1a3715b1b33d5845c4d53389f9dbcc6f9de8e2f983971f95732a5a2b90f1bd0d170d34359cf7dd294eb7a72f30a3002
│ │ │ ├── ca
│ │ │ │ ├── 87
│ │ │ │ │ └── 4a20524d4b42f751277b655d217ceeb1056a3c4319403050c7c8ff0667257b3a951e95ddd1ce7934cf7d1593e4af44057aa38fdfc44c54b3b33453189c66
│ │ │ │ ├── 97
│ │ │ │ │ └── 66254fd36c16f2d83c626eebfb64b5b706cd5012633b9c78c400d7e88492ef1345d5ba38ac9f5a8f25c67183ea83b9cb2bf9b3fa7cb0f5acf4b702127b11
│ │ │ │ ├── c4
│ │ │ │ │ └── fc9a1762c562ba1f0de2d55d80791a99e567d78351b8de6aa86253369dceb7f3c16ae63717cabe6646ca9588bc7f18961da0bd1b7d70fc9e617e667fc8a3
│ │ │ │ ├── d4
│ │ │ │ │ └── 080544005e733d3410ee04a580ae76e113c7c96cf6c46ef911e81db70436e4c5e31aeee0c4390aa643707d5df971f8f640d2b3cbbe2d6ba72d998a391b9d
│ │ │ │ └── ee
│ │ │ │ └── 294450a70a4b84bf3b89e152404c8f083f74a4ba786211b0155a743137bbf8eae432a8c53c73d6901f31714e573a3eade2972c4440e3a31bf1c8e3cbd1eb
│ │ │ ├── cb
│ │ │ │ └── 86
│ │ │ │ └── 2d309376a857f6fcfc38277e510b28f343876db7c89627103f93c9e61d4b32837103654fad9dfc59b28e3c41256aa36b70d43f5ca9e1d686c000cb8d04f3
│ │ │ ├── cd
│ │ │ │ └── b0
│ │ │ │ └── 7dac22404f5adb8e25436f686a2851cd60bc60b64f0d511c59dc86700f717a36dc5b5d94029e74a2d4b931f880e885d3e5169db6db05402c885e64941212
│ │ │ ├── cf
│ │ │ │ └── 87
│ │ │ │ └── aa26f7e236714c1c822f5cfdc2639ef2d9626ce60dafdd7d339bd984264ae436fe2b0f1bbeb20f4987c1245f27aa06407b48e71ba28f5d315aa1cab00222
│ │ │ ├── d0
│ │ │ │ └── d2
│ │ │ │ └── 50e0b14552e5a413b3b17f486d04a4baccb9248c11fe84cd6e93b360ef4e51791f26fee7a576ecb50c1a343f20573ca567040e9806553de0c0465eb4810b
│ │ │ ├── d1
│ │ │ │ └── 1f
│ │ │ │ └── 629116faebc1c1ed00f14f5be4a6e501b6a739dd8c80c0cc0679414a4688d8fcd58abdd67ef5462d45f1a686a35b4644d256931b9b28578a9145bf671bfc
│ │ │ ├── d2
│ │ │ │ └── b1
│ │ │ │ └── 60fd18f643ad8d0a6eb68d9c34417edadeccfa402414d0ba5974dac95fc6f2446686553a9bad6f630282001f2310aac369799f356204a2cceb79597ab43f
│ │ │ ├── d3
│ │ │ │ └── 40
│ │ │ │ └── 2ad23a9449077c89d8b4bbd6bf341d1ea1cf3711c191c9e4bb1f529d607c1f16c85709b8afcbcf0beb01181c36cd694b424413bfb590016508a7b4c3b0d2
│ │ │ ├── d5
│ │ │ │ └── 41
│ │ │ │ └── 16457ea39ce036cb81f959ccd9e3880e3a34c49a5aafd6e356e0600910ee7e6dab82061bfcb2763ae48c39fd5392fe084a37d82bd8a8e72cac6bb2fa0c57
│ │ │ ├── d9
│ │ │ │ └── d1
│ │ │ │ └── df4e80a3fe9cdc6b60a4ef6e0e6792f4115aebdde1d136c1bf6f7c5024b036859a55092f7d6cb017fa19b52075c3127cd4e9bcb9cffe4c218efde3f6bc35
│ │ │ ├── dc
│ │ │ │ ├── 17
│ │ │ │ │ └── a5b7ab5d73c6cf800b5b72676d349962ad5a139846f97b6802f783e7930116f6323a0801d47a81bce6d8d63f95aabaa7dabe832d330886e0ff76e9928ab9
│ │ │ │ ├── d6
│ │ │ │ │ └── 84b678e2efff1539dd12f7425ef76630d3778113ad0ec39e45589e122824507d3a7094f30c0542a0834a23f485fdd982d6bb91213f5ace9f249af4b49c6c
│ │ │ │ └── e4
│ │ │ │ └── b3dd369c516cb85ad397577f03820c31a2a24ae3e78390d325e59fcc2596a850f68fe3ff657fcd715cc7b523645e4c0a6dbdead95296cf638c16c16c8be6
│ │ │ ├── df
│ │ │ │ └── b6
│ │ │ │ └── 709849a279c02c19b1b4bdb6a81743d23ca14c40b8bdadcd835424e4c0b6afdfccc3f9421aa8be1837a5e111d4d5533ded5d7cf3f22830beb9a31bd60bfd
│ │ │ ├── e0
│ │ │ │ ├── 95
│ │ │ │ │ └── faac46ad404be59a053cd30672abd453f7a1d925af3cabc869d2905df8badccde0c8e28eae03633ebafc678151e8e0886bf2e89b5f11fafbbd3384016b57
│ │ │ │ └── a5
│ │ │ │ └── adbacd54192a2fe66c7b8f4ab78998b920ad0f70a69c47dd0de48302d7e4d32f017f420d92a8080765b0e0ed11759d04da6c85f6e30d6f992c8e0ff3a427
│ │ │ ├── e1
│ │ │ │ └── 71
│ │ │ │ └── f77479e68534ec1a2b93d8fc47c7a1399a534f50e98fda4e5c47d2d7210a51a869c271f2732f74df3aba4c3cbc0a5e2d47cc03390b056afb8d95767b0a3c
│ │ │ ├── e2
│ │ │ │ └── c4
│ │ │ │ └── e4fe3527435943bfd91bc759cde394aca00a43c56f218ca2ca7079c787d9df45510df525beca552336f5420cfef8c523690fcbf9a7a349c955ad6587cf58
│ │ │ ├── e6
│ │ │ │ ├── 31
│ │ │ │ │ └── c208522e3a132e9adde8101848478efcfdbd9d9dedef1a3498f8528e2e3bd63e9b03c11b1b689f80ef79cc3007e9d8113692b75d99b6cc8fd4fc524f3f15
│ │ │ │ └── 6e
│ │ │ │ └── 2740aa7ead945bd3d2cd1f9f463380714e1f76e75ff295b2886e97bb4e91b17c9fbd92fe812e42c15c88e3b296e06e720136a948db7b519d3593d2c9d423
│ │ │ ├── e7
│ │ │ │ ├── c4
│ │ │ │ │ └── bd403a86d17c76ed8c0f4adf5f2718af8d8978df6602c1f0cc7d9fbbd5102a52b65e7fb2eb2906772c72cec024b814b341a653f9df7671f3de5278e087bc
│ │ │ │ └── c9
│ │ │ │ └── 66c4a480e013722f3f871cc53394e129834f4557e7afe9931edef262860771ce073067c5681043e600b0991bd2e6a9f56834c30aa6db48613546eae0d8ec
│ │ │ ├── ea
│ │ │ │ └── 6a
│ │ │ │ └── e08b4fd9ee6e6504f13f3cdc682341d990770d134d9cb9eea062db05dbdeedec59beac621234d04aec080e7ecc761a0cb5ba6fb176d12a4c594e1affe34d
│ │ │ ├── eb
│ │ │ │ └── fb
│ │ │ │ └── f002c3c2e7371e2c96b7c632a51ed57545731aaaf1d2a2f7e4e81436dbbe703688886d65cad4a0e67a70677a5dd18e30f11710b5405773110be17ec09295
│ │ │ ├── ec
│ │ │ │ └── 0e
│ │ │ │ └── 92f634a09bf4beecc76d34349bf8853ce7dbd0a89fd002d71841c7c50ba5bc452e08c4864395d2d1d31a82159e830b2ad02e32cfb31b5335c8798d503894
│ │ │ ├── ee
│ │ │ │ └── 49
│ │ │ │ └── 3ab8e198f724a0085b11b91a655b3be3884c2e946f3bea97e78d0c6a681240714969dcdd72aceb7b61030166cc6fa29f911b0e7421e8623ee1acfbba21fb
│ │ │ ├── ef
│ │ │ │ ├── 17
│ │ │ │ │ └── 5c6ad83bfd4fbbf94772a23db3a1db48f47fc8228a6aa3e60e21c64eab59c9c1758167da7cc62bb99655e57a40db66471aefd6bf7e8cc46105c8038b16e8
│ │ │ │ └── 20
│ │ │ │ └── 10a43d94309ccb8b50eabfba856273db68fc7b65f14ae8f888c50e0f7e418fc8dca5d94831f9afee994a2798aaa384ce039df6ccbdd5faa2d5eaf37b2841
│ │ │ ├── f0
│ │ │ │ └── e4
│ │ │ │ └── a5493e3c7cf613ac0c16fb8ab8e0f240eec72decd3f67282dbb7528a041e4f509299294bd218553aa13f8255c4410e359acc0da417ab748ddb7f9e84870c
│ │ │ ├── f3
│ │ │ │ └── 3f
│ │ │ │ └── 5f545883735913820f7b9388c4bb8f5506d3a5342991621e9eb2d29c70ead7e24ed11fd239488463723f922bd375fd8cb1aeaf5d0118c7475cb516a11090
│ │ │ ├── f5
│ │ │ │ └── 3f
│ │ │ │ └── 548d6debd145b973543b193c25969b57c21bd8984cc587331f67d1fb1505adfae65e3e364f8c13ff5b5644c99d6dc065a89b9ff9e9317894f72a8e70c772
│ │ │ ├── f6
│ │ │ │ └── bf
│ │ │ │ └── b28bdfa6814df700a723e886d3f684423bbf16ae24a3eadfdc17c0d605927d68e18f393103bdd503cf51702a29bb4175b0987aad7479d125f840c441b8e9
│ │ │ ├── f8
│ │ │ │ └── 6d
│ │ │ │ └── ad94b9e6993772c5d9a05196731ca28aab1cec43bc63c70e16720eeb8905183896317bf54f03b08ead598d1c8574e8fd07f97f2344e801d4d99bb9997ac1
│ │ │ ├── fb
│ │ │ │ └── 07
│ │ │ │ └── 5b4f51db21cf13bb2531a41b5bb56490f2bdef064219525582fbc6edb0ace29922fb8613e7bf811cccabea9bf8bf817f3504b3cad598254fc5d28abfb7e4
│ │ │ ├── fc
│ │ │ │ └── cc
│ │ │ │ └── 2b4a058cdaf75b3dad8ffb7f2072d0d69160ad6b6cdddabfd348d4defb96799baa61adc2ad9c254944e9c3286516534e61c34ffd2bc242537aa40b056d5a
│ │ │ ├── fe
│ │ │ │ ├── 32
│ │ │ │ │ └── 99a0ca70d05f06470978fde2d138f03771f717b4b0293f44332e6513fc7b8f0995b207b218f59acc78ac363bf9c522a3d00773d533d6989b4177d760170d
│ │ │ │ ├── 37
│ │ │ │ │ └── c4c0d0dd41504236f8e41a2b7887aa4c3b3abc6c7928a6ae39f1d3edda5323c7e781414a2164d1bd03b0ed3bf3b9ba449bc6e68d1973231e2720c32eab41
│ │ │ │ └── b1
│ │ │ │ └── 5e0a934941b852663195c0ef51155df13ea6e71114bc326210cc2b43ff397a82926e57f6cc2ee37dda81b717b77ca031071d1aee8d25cd52bf1fa639ed2b
│ │ │ └── ff
│ │ │ └── 2e
│ │ │ └── ed24a00b559d653f3799641f636279adacbeddd0ddb3928ae28b96bbafb7611e4588b8b4f36696733092cad5d9984605ff34273889aad33b717b052d9cfc
│ │ └── index-v5
│ │ ├── 00
│ │ │ ├── b0
│ │ │ │ └── a5285b1dd41927c25a437d6e06e180ad401616f52c278cd64474969fb3e1
│ │ │ └── df
│ │ │ └── 216782e75230fb7e8d7057093e134da919f2d56aa9db5f6f7258b3b537d3
│ │ ├── 01
│ │ │ ├── 3c
│ │ │ │ └── 9305c09d5789a41fefc7aa0cd3a8a3813243d247f506487c2f66e9ff5971
│ │ │ ├── 85
│ │ │ │ └── ac002ce9e68821cd39a876c92f3e1be8caeddcf6419d6bc324f70d32b4e9
│ │ │ └── a9
│ │ │ └── b0d0d67beda769e84926f207549943c0bc17abbf66bc20099aaa1bb51736
│ │ ├── 02
│ │ │ └── 3d
│ │ │ └── 7ff49953c213d0e9070efaadaaf3c5ec6740893a6f3704b4f14e805bcfa2
│ │ ├── 03
│ │ │ └── 48
│ │ │ └── 75977735688016c583178c5e6055c5d811bf783ee09da9fe4b1137891c98
│ │ ├── 04
│ │ │ └── bb
│ │ │ └── e70e70e0cbc9b00841927b0c23c58d97f21063208f3e872c3e04db58c13b
│ │ ├── 06
│ │ │ ├── 5a
│ │ │ │ └── 98f8c4232b39b6ac68023a0bc186c128dffdec812a144648c26dac71f91a
│ │ │ └── 5e
│ │ │ └── 2009163f0b101c063269056e566eec4bbc4ec9c8e69f769867337a8ed57b
│ │ ├── 07
│ │ │ └── 2f
│ │ │ └── c26409f0f3f5f0a9723c9865acfaf682ce8a5f593e491d912d58f53f9ae7
│ │ ├── 08
│ │ │ └── b9
│ │ │ └── 8c0c17709bc08fb63e5f0c39c65b93c80c9663f548e949eb55cb434a357a
│ │ ├── 09
│ │ │ └── 8b
│ │ │ └── 0ac0d0ead7b0eee61d826bc69cca1c7d40e187e8282c876253d740b9e9f0
│ │ ├── 0a
│ │ │ ├── 08
│ │ │ │ └── 7555feef8088d2832129af7ce022f6637283712a9ecd731e4a9ef4932c14
│ │ │ ├── 2c
│ │ │ │ └── 10ae97cc0ddca9e23bc5e1c1a10c38f60b99fa734eb5749276bb78987586
│ │ │ └── a2
│ │ │ └── 6a45098c63203072b3c3abfd9346c85ac9bc463e9506bc2bdf17478905a3
│ │ ├── 0d
│ │ │ └── b3
│ │ │ └── 097d1aa2272aa0a4559d84bc3e8aa1b5438104f60d0a303dd8cf4a4919e2
│ │ ├── 0f
│ │ │ └── f7
│ │ │ └── ef3ad5111001a610f814d854d1ce9853e9d6d710a41430d086d07a0986cb
│ │ ├── 10
│ │ │ └── 17
│ │ │ └── fba3d249f38fffb6e9b99fc904d81622ca3edbd864d546795aece3329bb4
│ │ ├── 11
│ │ │ ├── 42
│ │ │ │ └── 63f22fbcf0c21b1e268e7098ba936a48f7ddd6c06761a6c5b4a5fe434ebf
│ │ │ └── d4
│ │ │ └── 2f9f9df8a204a306e5baed8f658a43e437792315d561c5eb0315c7a97d50
│ │ ├── 16
│ │ │ └── cb
│ │ │ └── 5a69d7ce799d5fc7d26a2056473c94a7bb373b72395bb56a9b740dffd152
│ │ ├── 1c
│ │ │ └── 65
│ │ │ └── 74c26755259935f238329c24af2f3305f57b1107f720cc0082e513d83ebb
│ │ ├── 1d
│ │ │ └── 59
│ │ │ └── c56cdb49f40694dc6b984bd43ff53d96f6ea1dbb06ee467a00e4a697e664
│ │ ├── 1f
│ │ │ └── 85
│ │ │ └── 3e0b21cc5deb10a0dc51ed6dace9f5ae0f08f66b5c064b262517165cfa2f
│ │ ├── 27
│ │ │ └── ef
│ │ │ └── 452a94b385f28d524a6fd9178863fe32cc70bc3d94033a3dda9c91b2e128
│ │ ├── 2b
│ │ │ ├── 0f
│ │ │ │ └── b8787add1f0675f7298f5d4e498f1c0091c7438fd73df02d649bbcc9c1ce
│ │ │ └── 2e
│ │ │ └── aa61c0bc2734278e23d60eeeab1fd752744ea5536b3ba08b35b3a667d229
│ │ ├── 2d
│ │ │ ├── 80
│ │ │ │ └── b5e9ca2e40744e7fa089861626d2a29c62363c01729964f4cf0c3e8ee632
│ │ │ └── f4
│ │ │ └── 9196d70f82f15d107105ed433fd462721c91b1594984d87b54d57730cb20
│ │ ├── 2e
│ │ │ └── 5e
│ │ │ └── 52bb770674006416c55571d38721a1575036bc260e9debd40db850bc0b20
│ │ ├── 2f
│ │ │ └── 2c
│ │ │ └── 2a12420aab34889ed2c64b80f9b722e2e90e139a130f13e34a1c7a0e1e29
│ │ ├── 31
│ │ │ ├── 7a
│ │ │ │ └── 9c96d52885c2170f2365ba2c1bb1035008b9daa92b20f4c5e52f16b85113
│ │ │ └── ca
│ │ │ └── a8c3ab0670811a3887ede187dcd3856d14272349a18f6844f7c8007cc05e
│ │ ├── 33
│ │ │ ├── 19
│ │ │ │ └── a311e591a2b51610ed276fe9968065a74c2f19efd7f917616967040ce127
│ │ │ └── f9
│ │ │ └── 071d7d949ade71febc395082397753f9a225031462df3ac9c8ff4104bbad
│ │ ├── 34
│ │ │ ├── 05
│ │ │ │ └── 127f37b0ff3cd9c76b1497b5838d265a8a2b7ef495b7f9841f5d4665ba67
│ │ │ └── 9e
│ │ │ └── 35f5913aa7a542b3357025e12a2a126c13ab15a9bfbb40721b56f89ecb48
│ │ ├── 35
│ │ │ ├── 45
│ │ │ │ └── acc6960018d880bf033f23b050a6c442be8b02eb6cd96e01c7ef7b61b640
│ │ │ └── fd
│ │ │ └── 45154839db33174def1653b1ca377b1d2a65a4c4e56564fe11d85b67a96e
│ │ ├── 38
│ │ │ ├── 04
│ │ │ │ └── a49ce7d19c6d98ec2d5f259e71f17a5727961200c4cf22a88e33ff7bbe5c
│ │ │ └── 36
│ │ │ └── 08fcd3ee98bd9b00bb28cc7d417209f374feb4bb23f9093fdab5ff57857b
│ │ ├── 3a
│ │ │ ├── 10
│ │ │ │ └── 33ebb16ca229c4cbdad65ac0947fbeb3765befe98674faa960578851637f
│ │ │ ├── 21
│ │ │ │ └── 946df9356ae372c19a7700e322d8d0276a406143c7375ce22124fad7dfcd
│ │ │ └── 46
│ │ │ └── 4a802da9ee2134f8f76df15df8ddd2d0f2b05e7de9b1d7e01669c4278824
│ │ ├── 3c
│ │ │ └── f6
│ │ │ └── 26a7f7dccb969c764b8bdecb3667023c64bc1159e674fbeeca633c54964c
│ │ ├── 3d
│ │ │ └── 2f
│ │ │ └── f8441bbef005e18fb70c8e8654894abf17ac44b2140cfd60f172246d894f
│ │ ├── 3e
│ │ │ └── 49
│ │ │ └── fc9a5a5b33508297834c9a4acf4d4de5b46348df8093fa7d0a6f82aba3d5
│ │ ├── 3f
│ │ │ ├── 3a
│ │ │ │ └── 2f0714110028b8f228c7c95100ea873c5a00ea03a97ed1d1f555cd404e1f
│ │ │ └── 55
│ │ │ └── a551d4620944369d858a04648adf3994a33934840d738144392e51784ac1
│ │ ├── 40
│ │ │ ├── 17
│ │ │ │ └── 8828f1bc3c004a75e5f93ab594b7418ca18ac8660a28916cc6e51643994d
│ │ │ └── 1e
│ │ │ └── 89f0b89d2ca92cd54ff481086fdd599c67170ea69eb9b22d37e34638d25e
│ │ ├── 42
│ │ │ └── 8b
│ │ │ └── c02d827ace565a38508b184eec46432a592ba2550cdb1930cd90b866d766
│ │ ├── 43
│ │ │ ├── 5f
│ │ │ │ └── 110819c5903563df1824b2214749ef7781289e80d4a600347e3901aac1c4
│ │ │ └── b0
│ │ │ └── 1da35d6e384e0146648258aa5ea61333fd10d6d00300adf4aac974f6d1e2
│ │ ├── 44
│ │ │ └── 10
│ │ │ └── 7cf4f1b3974687000c3e81a7b9d017adb6b8416e32f27309b764b12b8be5
│ │ ├── 45
│ │ │ └── 2e
│ │ │ └── 93eac58d3d5aa3f5721ac09fa7c3b814ccb98bc5000550243f4497f78a67
│ │ ├── 46
│ │ │ └── 98
│ │ │ └── 3144eac06844196da14c933cccc766b529c8917a7efc1c6c79bba5651a6e
│ │ ├── 47
│ │ │ └── 12
│ │ │ └── 2b0123c780f4536fbd0b803d54bb573a256230046b95fd342da9df92dc8d
│ │ ├── 48
│ │ │ ├── 7f
│ │ │ │ └── 4f4a841cc66ee33998620da1f4f341e422d9ebb37bb00178f3707927db1b
│ │ │ ├── ae
│ │ │ │ ├── 1499701156e55c38f37c319e42d8ee632f62ee16e676fb96bf268dc03e39
│ │ │ │ └── f6dae96ac72c3518cd54e6a1cf5ac3bc59c80cfdc62d65a101a0cb67304a
│ │ │ └── dd
│ │ │ └── 8c8b3dd9e0048fc9974197e48fdfa5ceb084560780473574323b9bfdebd4
│ │ ├── 4e
│ │ │ ├── 45
│ │ │ │ └── 17bdb2bc7c0f1b72ba954a40424fb4a9ef5929f88e922704c80b3d264ccc
│ │ │ └── be
│ │ │ └── da18b216664b1e58df4ffd6782d77f3c28a3f61355544535ff7704cc1b2d
│ │ ├── 50
│ │ │ ├── 85
│ │ │ │ └── a29f2ec233233dedaf6d110ada83bf22af3e52848fda04a91b64f889f53a
│ │ │ └── bb
│ │ │ └── 1a5b513e51544ef3ffcb8dade26b2fd155f2f50104e8ac073030a9d119ee
│ │ ├── 51
│ │ │ └── 89
│ │ │ └── 3d02d342de41905761accac02260bce79c49652be9e6066da254d77ba04d
│ │ ├── 52
│ │ │ ├── 20
│ │ │ │ └── 702ec5d12a1e111e2534ce89eb0f33f79fe3ffee0e80a428299cdaa0d007
│ │ │ ├── a2
│ │ │ │ └── ba77c6a126c66982a48c1fb49ac1ca7f841619a89a1f0fc5de3512a4b7f0
│ │ │ └── bd
│ │ │ └── 1b45d5168ed8296f6d5d5167fe2f8076e2cd5e5d67d2766935784d3e798d
│ │ ├── 53
│ │ │ └── e1
│ │ │ └── 0dc9829fd62522b01d70c6eff1025e862877619ba63ab3f1445df0451b8c
│ │ ├── 56
│ │ │ ├── 4b
│ │ │ │ └── 859813b09e1e5020654bf65fb2f19970c51f08f788d3c4f2ea5137051e1e
│ │ │ ├── 71
│ │ │ │ └── fa4fe23b6bc134c60d26da3033c87003fb50204af907f8ec32c9a7c9e48c
│ │ │ └── 9b
│ │ │ └── 5bc545281ee1f49775ff8b0f2921a08251d503d559ff3f999be9886f1712
│ │ ├── 57
│ │ │ └── b7
│ │ │ └── 2772f8c4daa4b31074e03545f8e473b547e88ef3141501fe2a54e1abdfc4
│ │ ├── 58
│ │ │ ├── 92
│ │ │ │ └── 5799a11997482f78a71307f2134a84b508b74d7faa3535d40d26c6261638
│ │ │ └── f0
│ │ │ └── 4fe556f104b09be642895a82afa463fe560d9a0dc8f507efeef825a6905e
│ │ ├── 5b
│ │ │ └── 42
│ │ │ └── b4487d788874a06f49235360174f1ba8832e8f6a83cb8533883b8fa09f4b
│ │ ├── 5d
│ │ │ ├── 58
│ │ │ │ └── 39fdc57612a04067ef7ec1c141646752e6563b84430cd56ba1df2434de91
│ │ │ └── ad
│ │ │ └── 1cb61ae613816d5f049cd87dd24009e364126f73726b1f8eab2350fec505
│ │ ├── 60
│ │ │ └── df
│ │ │ └── 89f1345cb5849d888a2cce2e6d6ddc0014eb3d6722956a06241f6e7f3d58
│ │ ├── 63
│ │ │ └── d3
│ │ │ └── bb861348e4b5fc53b62454cd498b01af8a51c93c0ebb3f9ca712ca253566
│ │ ├── 69
│ │ │ ├── 33
│ │ │ │ └── b968e19e42cda755b43c4bd1e354056b2be0e8ff44896e82e4bc9fdb6322
│ │ │ ├── 7f
│ │ │ │ └── ee4d73554ca4b3320cb01b422b9a9d45f388513d8fd2ccf4df9187578ce1
│ │ │ └── 97
│ │ │ └── dc07bc0d29ed2880b0e39905e8bc8a24a0344155c90a7ca65c8093d51295
│ │ ├── 6a
│ │ │ ├── 86
│ │ │ │ └── 14653864a77b7c8644710834018401ea9fd5653744bbbea2201a6af48a9f
│ │ │ └── a7
│ │ │ └── 23f89bea37ae703ce622e7188ccb889113f1d355f754c11544a1caec4cc6
│ │ ├── 6d
│ │ │ ├── 40
│ │ │ │ └── 0b02ee474cc305b6d0da00248cfa61780731440b4f237c6251314258b9bd
│ │ │ ├── 61
│ │ │ │ └── c9e7e8446341cea439547eb023fbf47c954ba932e6944a3fd50413c1e861
│ │ │ └── 65
│ │ │ └── 05c74d488e52e860b9de3668e482a62f5796264d2bf9f2700cf9423add5e
│ │ ├── 6e
│ │ │ └── 9e
│ │ │ └── 2004cc0984629401a6a3d3fa16900d49ac70112df7a8c515ec028b34c59d
│ │ ├── 6f
│ │ │ └── 9f
│ │ │ └── 4244544732d3e784c8fd360e0ea256a943488c53a834da3d0ddf3e83af9b
│ │ ├── 73
│ │ │ ├── c1
│ │ │ │ └── d8bbb109a8fa2903d912518bf54776b7794c8f6f0a759234283c3c2eefab
│ │ │ └── e2
│ │ │ └── 434e6cce71a37629e1945f6d35d5e52c1e34aa88ef24d1915846c72775f1
│ │ ├── 77
│ │ │ ├── 59
│ │ │ │ └── 986079464467eb2c4f1c178bf1c9fa9179b3c8384bd1eff68534419250ea
│ │ │ └── d8
│ │ │ └── 4c73393b4c86b064a434ecae7c4c202784cc49493fdc99469a7dc797494b
│ │ ├── 79
│ │ │ └── 0e
│ │ │ └── e6e294a39cc9407b6358b7284df63feda5d4f96e51519630d06219175167
│ │ ├── 7a
│ │ │ ├── 05
│ │ │ │ └── 8c39e8b9b5af7db5ea9983334f3ee2532aae9b7973de1dbb581781947ed3
│ │ │ ├── 1d
│ │ │ │ └── aa5b15d3f974ebd32c44778518e0984265598aa1e2dddc4ded4feb2a11b1
│ │ │ └── 23
│ │ │ └── df8deeb6de869825106ce68786ba9e16686f20a8b4f1c626c9635a5bc8da
│ │ ├── 7b
│ │ │ └── 1d
│ │ │ └── 314b6515b77b62a66c8a2ac140ac4a6926135c5866837fddded37acb1acf
│ │ ├── 7c
│ │ │ ├── 20
│ │ │ │ └── cba9852dc5e0811d9e6e24e74108bf7727a0c2730516ec8f41a08f13116b
│ │ │ └── 9a
│ │ │ └── 13a1f5cfe2738ebf2558b3fc8173e47bffd478a46c35ee5e0fc6e72e511d
│ │ ├── 7d
│ │ │ └── e8
│ │ │ └── 5446c5cdae0493e4ad3b10347b77c8df4b17b5fbe14834f5c6b06faa9f95
│ │ ├── 7f
│ │ │ ├── d5
│ │ │ │ └── 36068d8df17b31ccdbeedbb62ae94e354f6d768324e0dd6578917b8ecc16
│ │ │ └── f6
│ │ │ └── 5e3925b158405271b2f44be4d1ecbb5c60b3b7da87819ce03956b759b051
│ │ ├── 83
│ │ │ └── ef
│ │ │ └── aff47278d7ef72e864717a2bb5e09eca947c1b761d2a3f590af1b5f1b379
│ │ ├── 85
│ │ │ ├── 20
│ │ │ │ └── 71a0d0584d5ae3631b6b48b18785908616327f10115d683585b05072ca1b
│ │ │ ├── d3
│ │ │ │ └── 1b45f9b1e17b38c211d236888c737ca95cd5b9ca0e42c51cff12aece643f
│ │ │ └── d8
│ │ │ └── 7da2d1eaa517a5e80f7a1a8d7dee184babfd49523097c7b2ea907d755944
│ │ ├── 86
│ │ │ └── df
│ │ │ └── f30ac40daf6afa3c806cd525ffbf33eaad06c5f38e08f7ce9428a303241e
│ │ ├── 87
│ │ │ └── eb
│ │ │ └── ab402da37b8ea447b0cac7c54cf3452aae056ac8c63514cb6730629409a8
│ │ ├── 89
│ │ │ ├── 0b
│ │ │ │ └── e2ba88ed525834b932f3ddb5624a540e279742a3c6851ec4ee466890a5ed
│ │ │ ├── 0c
│ │ │ │ └── 98d70e9e25b9a23c255f11b8acd5d9ebed836d0004871577846f3bc3f03f
│ │ │ ├── 39
│ │ │ │ └── d7518a088b510f892a8355a21e2971328f68a8ef26d1962bbcfc70c84725
│ │ │ └── 58
│ │ │ └── 62a9a2b49fd26f8d788adbe5cc377e776463c3a01839945896d96fa48d4f
│ │ ├── 8a
│ │ │ ├── e9
│ │ │ │ └── f78a927b119d27ece8b731dfde1470b48159f26c89ce35d5fe0fc80122ed
│ │ │ └── ea
│ │ │ └── a9d2d6ff75cba71d63171f51aa258a77d99513740280af3884c1dea1f7cd
│ │ ├── 8b
│ │ │ ├── 4c
│ │ │ │ └── 6c0c483d470762dc61c704d8d07e1edd6421400f274c32ea22f543bfdb16
│ │ │ ├── d9
│ │ │ │ └── 617f84454e0342f885f6cbdd2661990c9060f183e29553e39e0506dbd847
│ │ │ └── ee
│ │ │ └── c2ea22c4bf9c5ddcd0333850e543442de3364478847c7ebc382b1ff3a70d
│ │ ├── 8c
│ │ │ └── 9a
│ │ │ └── e014072a08e7ba0b90a6897c5737bc438be37650b0470bfd7c0b83e18e23
│ │ ├── 8e
│ │ │ ├── 58
│ │ │ │ └── 1ce1355f39c75fa063f8dc1c958c11d57446438253b206afc18efb9f28c9
│ │ │ └── ff
│ │ │ └── fc9a834a298aa364d38f286bfc395217fe0559c9b322231ff5f6265ba504
│ │ ├── 91
│ │ │ └── 08
│ │ │ └── 56fc6b8aa67287e6e60a90a5e8bd6500ef9e97a317a38b324cca616a7d25
│ │ ├── 93
│ │ │ └── 31
│ │ │ └── 9f96e29572a9b3bd880f19dde2e443b99ec81a4258f3e56ce1c4fff64852
│ │ ├── 94
│ │ │ ├── 07
│ │ │ │ └── a7c22ba183764c0c27f706d74812444c27c14a97fc43669b7dd7c32a717f
│ │ │ └── 49
│ │ │ └── 0c8e6bfaa289aa93424dc1f6f28b3decc9f59cb08be977c3040f7d244ac3
│ │ ├── 96
│ │ │ ├── 7c
│ │ │ │ └── 454eb1ff3ec3546d35165170f771ff1c65f055203c5ab9f907e6af7067a8
│ │ │ └── c5
│ │ │ └── cfd4f290453cd7201716a3217433fe76e994d06ad3a598a6ab5772d5280f
│ │ ├── 98
│ │ │ └── fe
│ │ │ └── c68a85433f7c743aa9b9427fb21be6fd8c25f9e7893bd5cf65537496008d
│ │ ├── 9a
│ │ │ ├── 76
│ │ │ │ └── 06192603daebdeebec6ad6e070357bb297b864354a3998c359fa50ad570b
│ │ │ └── bc
│ │ │ └── 143ae50ba22ddec235347ed6a62762b673eddb52cb1939aea401679de36b
│ │ ├── 9d
│ │ │ └── 0d
│ │ │ └── cb301e666cb1b3f23405c9a023a97e35e0b646458b0dc07d4e4c45f072d2
│ │ ├── 9e
│ │ │ └── 24
│ │ │ └── 74490f75d8dec7ba5051c2fb1e3119fa15abb79366ea7664e5fbb2977153
│ │ ├── 9f
│ │ │ └── 43
│ │ │ └── 3636172cbc03abf2262c921f9f71572e6b049aa3db8c65d166bcfe5aca5f
│ │ ├── a1
│ │ │ └── 78
│ │ │ └── ee48142ac207e21a1a2eac9ca7111587ce699eebdc565abb3dfe976abf96
│ │ ├── a2
│ │ │ ├── 60
│ │ │ │ └── ea4e9555df962e8a55d27858ec6e935db7b0356b46d10718029046780c27
│ │ │ ├── 68
│ │ │ │ └── b7b4c1f69b4b4ff6c19e7de1b75dfa3eefbab3d36b6ce4ef15d6f64afb9c
│ │ │ └── b5
│ │ │ └── f2c35332a5ab256ee9271034e3b3b301ece6931e6e92531ca0bd8c08fe9a
│ │ ├── a3
│ │ │ └── 50
│ │ │ └── b739b1f6f936987c26973cec93f36482ed240ab90158c0d04899bab0de13
│ │ ├── a4
│ │ │ └── b7
│ │ │ └── a7cebac941d6c47ac2f6fde93c17edf93f4ae4aa6b051499d8f2ffeab614
│ │ ├── a5
│ │ │ ├── 87
│ │ │ │ └── bc838260e09216f01f45e48f0f96cb7691d978001a792540928b1153baa5
│ │ │ └── b8
│ │ │ └── 454c882933ab15d532e2493b0bd7ce7019f1caca2abb46f076ca0855330b
│ │ ├── a6
│ │ │ └── 54
│ │ │ └── c1733144b73a0422b1daf6390b4562d52ec887d209b643d8b0b789a2e4b1
│ │ ├── a7
│ │ │ └── 04
│ │ │ └── d0646f5e87aed79d9f0ad28e40eff59b4872fd92336c436b29f7280a9d3a
│ │ ├── a9
│ │ │ ├── 92
│ │ │ │ └── c230215c94371d341f1b38927e5f481994a870132101fd50efb0449f27c2
│ │ │ └── f7
│ │ │ └── 4c2a9fe6575921726a5579be73ddb2a3e8a7abbbb66a28c50ca8deaeccc5
│ │ ├── aa
│ │ │ └── cb
│ │ │ └── eb7e78deaaf4e5eba36039b514bbe6541a5e440f56bda5447a6a0c81f2aa
│ │ ├── ab
│ │ │ └── f0
│ │ │ └── 041961d523d853b40e4e55be33fe676651a97b630d01af1b06b28abc5697
│ │ ├── ac
│ │ │ ├── 5d
│ │ │ │ └── bac3965880e0e18bc7d1e21519c9073430f53c69821d54a4aeb5c313357f
│ │ │ └── 86
│ │ │ └── c0732592365d753d382502d91754a3c88f8b20e22cc25a0327beb9429687
│ │ ├── ad
│ │ │ ├── 5c
│ │ │ │ └── 217f4a9502eed2896935b005b187e4713d93ba3dc76eff284b00a1a8b92a
│ │ │ └── 7c
│ │ │ └── cc598261aa7c1f089fdcd0478664f8f5c80f8f02f241f08e3be264a9e616
│ │ ├── ae
│ │ │ └── 78
│ │ │ └── cedd14d309b153583ec33b511626642a5b2cecfae082a664e1e6a368bc97
│ │ ├── af
│ │ │ └── 8a
│ │ │ └── d90cfcd33a9895fbbb880406407aee65cd5b37556b94baafb95ba5cb93dd
│ │ ├── b0
│ │ │ └── 4a
│ │ │ └── c18a99a2710b49b5a3a1121226be4940f623f8ba056f8108a634ed347da9
│ │ ├── b1
│ │ │ ├── 4a
│ │ │ │ └── 6796e751962cdc0f1d356f7c34ae7e66a41858d769156329b5bd4379d591
│ │ │ └── 8f
│ │ │ └── 5767f914aa664f32503df614481bac973784e2bcd2b8af02e84faabe168d
│ │ ├── b2
│ │ │ └── 53
│ │ │ └── a51760f3239bd143eb2f11ec8f083702e47b0ca67ac04a9a45e7336f6cde
│ │ ├── b3
│ │ │ └── 63
│ │ │ └── f693e1cbbd8c651339dc83ea677e236d61935b81de6396cb4847fd5b08e4
│ │ ├── b4
│ │ │ └── d4
│ │ │ └── aa802aaebfa5cce97b6f2e688062d965ef9940c20866c45eb34a72b47d05
│ │ ├── b7
│ │ │ ├── 38
│ │ │ │ └── 992d3e6c01fc9098d137f7dbccfcaa5f5124ba9c487e582e6e0d83f99d30
│ │ │ └── fe
│ │ │ └── e66fb9a38a1ef7da481d041bc0dd117c0c2bddfa61bcf516da1e1486c290
│ │ ├── bd
│ │ │ └── e8
│ │ │ └── 7741857e809594830141a639d3d54110945a88bb85691de2f9dc97402c84
│ │ ├── be
│ │ │ ├── a3
│ │ │ │ └── c0779c8e0be92c748c91a7dad4e6f0fe57ba0158b6bb1bcfddd8fc56c934
│ │ │ └── f0
│ │ │ └── 1030b67d1c2d501a0e14ff9aea82addbf8b2e760ef58a5be510d7b4bad3c
│ │ ├── bf
│ │ │ ├── 03
│ │ │ │ └── d5dd5fa44593b3e2d24e270c89a4ebe5809a69837946acbe11b5f9ab29d0
│ │ │ └── 7c
│ │ │ └── 375aec77f76404d91225e72006a0105b2a6ec04bb02cfa365ebcd4a0232b
│ │ ├── c0
│ │ │ └── 83
│ │ │ └── 1295af917239a2fbe94404f49d472949b2a2519701a35e8dc9841f02ae34
│ │ ├── c1
│ │ │ ├── 3e
│ │ │ │ └── 4c4d082623156529b4fa73601a4ac92e33a6b20f963f1096cee31b6d9010
│ │ │ └── 8c
│ │ │ └── e4e9afe177a9d6771d71fe96d51887f262a8fede9d9d3e06ca7ddcf20990
│ │ ├── c2
│ │ │ └── d9
│ │ │ └── 7fb959fc2a833b8e68b8306a1b7d4cd5f15c8b4e0c9d6b46a6765796482e
│ │ ├── c3
│ │ │ └── c6
│ │ │ └── be9e8d92e3e1f8898fedbe33cae4e67f0352de1b0d48fee9cb29ecc1d6ab
│ │ ├── c4
│ │ │ ├── 11
│ │ │ │ └── bf2dd5bf2d9b9006f82aeedaffc7f69ad64358a9a08afe81cbcdca1766f2
│ │ │ ├── 68
│ │ │ │ └── b71baf5025326649162df1bd325b5637dd1e72f59a32177b49318d5efeac
│ │ │ ├── ac
│ │ │ │ └── 4511be3eecea50ee9cadc09a612f9be8598d7b29d5c8b1253c75fa283cc5
│ │ │ └── ca
│ │ │ └── df46b5b6c6148487b1afb20084da52f2838a08143f9b0ebd217d2a229e9a
│ │ ├── ca
│ │ │ ├── 98
│ │ │ │ └── 29ae16b7b413d7a609c6beba2ab22ac51a8f88aa3c3a36759292907ce3ac
│ │ │ └── f8
│ │ │ └── 5fdf8973f1896e77c07a4919f6166c6a04ef8354c5efb0156670a06d24e3
│ │ ├── cb
│ │ │ └── c7
│ │ │ └── 8dc870ee1a760dfda5ed1c13aec5056dae100cec5c9af892474d802a65b0
│ │ ├── cc
│ │ │ ├── 25
│ │ │ │ └── 0a0ad2d0308b6807a70e488194992de068d68b749910eee4847c38629984
│ │ │ ├── 60
│ │ │ │ └── ca5eb4c028e64ab99a3a71e5e6cff685d49a0052a23f473310db7d984f23
│ │ │ └── fb
│ │ │ └── 96cd6e2c34dfd1fc2a68d5b85c353ec81fec75a8e0856070c12777141d13
│ │ ├── d0
│ │ │ ├── 12
│ │ │ │ └── 0e893a332c0e07c4e6ad382322604cf61f86ba7822a3e02b24d4105846cb
│ │ │ ├── 39
│ │ │ │ └── f3ea46b7a48d1b108681523c9e802f48f2779894068bc9b984863ca18939
│ │ │ ├── 57
│ │ │ │ └── 3aa5d94761ad382e1a1acc61203736494009e20422bce1dd1433666dd012
│ │ │ └── f3
│ │ │ └── 570007f66e0a594c21201eb3e8f15d7a4d92bcb97b59246e5b7194b3b290
│ │ ├── d1
│ │ │ ├── 34
│ │ │ │ └── dd11aca2ddd3aeb854849cd81cab78174fc5ea935c0fd552de94684f90a8
│ │ │ ├── 3b
│ │ │ │ └── 5d145862c809774efedb998cae0b11c4062b94265112f8db93a55edb929e
│ │ │ └── 91
│ │ │ └── 1ea8e1c5735aa7333775abaea09cba50e98296556053fba7d4dd227c6732
│ │ ├── d2
│ │ │ ├── 3c
│ │ │ │ └── 9b2e81a9ef349bd31c3c94f1c2d4040643ee96b8128c972db597415d555c
│ │ │ └── 53
│ │ │ └── 0423c306fc66318eb336eeb4033781a7b495f0aa3ba92eec00f34069f13e
│ │ ├── d4
│ │ │ ├── 42
│ │ │ │ └── dcecd9ea33544599eb1e71ac0fd23e843f4caf0dd35ae634e5a1e2bca450
│ │ │ ├── 8f
│ │ │ │ └── 715a86aa779da41ab634b8f3191069d4b2966a3c5b47cb739ab6a9b93aec
│ │ │ └── a2
│ │ │ └── 61ef4c73c2a4a1a021b2b9d9d54cd0acbea9f5e44cebff230278f27bd92a
│ │ ├── d5
│ │ │ └── f4
│ │ │ └── 0913a74f5e223a4fe6108493dd3b03c2d47259df459926160659513c9ad3
│ │ ├── d6
│ │ │ ├── 3c
│ │ │ │ └── 3fd6a899c59ae533d9a5bb44570ada1eddb5802483d3e7812df2c207a7e1
│ │ │ ├── 47
│ │ │ │ └── 2d4e4b363564f0b3d6e59012bb07573fb947a866841f5259a96439aa3964
│ │ │ └── 4d
│ │ │ └── 95351bd7b1c4630fa6590049d83b56ced950f5f2fd281f27e28527249cee
│ │ ├── d7
│ │ │ └── 98
│ │ │ └── 895bffa858148e74eb0bae5ede536d11e4eb6ba643223069874bea4f6498
│ │ ├── d8
│ │ │ ├── 62
│ │ │ │ └── fa9d7982c1af34cc1664c1504cdcf5728bee5cbfba341507a5c033098737
│ │ │ └── f2
│ │ │ └── dfd78c09b8752f2fd7100ea4a9f64cec29a053d57d72983420eb853b3e6a
│ │ ├── dc
│ │ │ ├── 47
│ │ │ │ └── 9e3985de44e70129e4e28c25bdc69a204acabcbdd5962cf5109db4ca7aa5
│ │ │ └── 8a
│ │ │ └── 4dc2a1bdf5b195e99648a945ce742de5f6d0b1aac410a6fe3e7155933cc7
│ │ ├── e1
│ │ │ └── 53
│ │ │ └── 4da55a553f57b5ef4eb84d567d8d4fbd67732c8c090da290c199e0ac2ed4
│ │ ├── e3
│ │ │ └── c5
│ │ │ └── ad2fd86fe0c1b9f233d92c25e56b1a582b8425b52db4767f8d72410c021f
│ │ ├── e4
│ │ │ └── f2
│ │ │ └── 0b57f65571788559ed93ba6d26cacaac21da8e4adfe374787669e431e875
│ │ ├── e6
│ │ │ ├── 37
│ │ │ │ └── c9e69f5074e9a22c766ffcc622280d4e580d2ee0238f670f28199487dd44
│ │ │ └── f1
│ │ │ └── aa87087a727f6fb26b60b78c06c2b830f509c809c7b1752ab1bcab0a15af
│ │ ├── e7
│ │ │ ├── 40
│ │ │ │ └── 70186a6ceaad19b6b11ac1bccf00fa5e038b8151d455127f9868f0051d57
│ │ │ ├── 6f
│ │ │ │ └── 6df2d13a4e315af18cce3e1c8a09c911262fc54f57e6fc47d361ddcf408d
│ │ │ ├── 9e
│ │ │ │ └── 9df988403d9266b9610bf520678520e200090b726c2ea164a0fe727500ba
│ │ │ ├── a3
│ │ │ │ └── 60cfc8947cb925b4deffc13cf15258a667e1653daa12cf0001b2e0083bfb
│ │ │ └── e9
│ │ │ └── d2369beb18730dc4f30e1c9dcdf5bf16ac9bd28dec641b81ff8e8616e7fc
│ │ ├── e9
│ │ │ ├── 6e
│ │ │ │ └── ba29811d787f0fd92ce7f4bc3a6827dc6d66c47153d50683c80d6e7a9a6f
│ │ │ ├── 9a
│ │ │ │ └── b309e8b758264ef32fd578a2928ad1ac4a3241e8c570a5c275e121dd7ee1
│ │ │ ├── bf
│ │ │ │ └── 0bfc4abc982e4aecac42d77dbded146ef0ce46649865b55d62144af5a96d
│ │ │ ├── cb
│ │ │ │ └── b6d58aac267a95803951157a42d29db6c17ef57c66eb59c48684c280e4e8
│ │ │ └── df
│ │ │ └── 500f6d65c0cf35c0f7c0635f953b37393168aa27cb55c7b0ce3399c0d7f2
│ │ ├── ec
│ │ │ ├── 87
│ │ │ │ └── d81e1e7b2d776e609dbfaa2175a5825c0a63a9bcc70fdb5694b81e7f4fc3
│ │ │ └── 8e
│ │ │ └── 97eeecddd26637708519813d42ee2a5ec256bd4831ffa02269e8993e19b7
│ │ ├── ed
│ │ │ └── 40
│ │ │ └── e67da4ad085eef0344d8e253e4455423e0efc042d3898be0a399d1a76b79
│ │ ├── ee
│ │ │ ├── 3d
│ │ │ │ └── 1ab77d088759d13cd44eab2a2f7764233b7908340d97282d9765e014f29c
│ │ │ ├── 60
│ │ │ │ └── 850558038dbacbcba5202b181a0a0c4f947405cf3682df3e1c20dec79137
│ │ │ └── 7a
│ │ │ └── ee0e1b8bea3f05c1b42f1fe4a17fdc2aa37be14405f4e293de10bd30eb80
│ │ ├── f1
│ │ │ ├── 53
│ │ │ │ └── 8aee994a2b5c701755cdc5660748a90199cf48437f5f93fdd0572344f2f1
│ │ │ └── a1
│ │ │ └── 1de8ff1c9230508fdf1c71b3faa1a9d2aade80a7e0b0d4daa6f4040d8ba2
│ │ ├── f3
│ │ │ ├── 2c
│ │ │ │ └── 80267cf9b394a43404ccabe3e574f5fd89b769b43be625b75ff9b1b4a2ee
│ │ │ ├── 8b
│ │ │ │ └── 4a6b7b0714b6f1c94fff48ad31ee18cb6aa93ed63612067b4de30efd43f8
│ │ │ └── f5
│ │ │ └── d11839881d6df2061b642074ebfaf84ce0d4b1d8e227ad335d364cf6a913
│ │ ├── f4
│ │ │ └── 47
│ │ │ └── 8cb011f7e5de40eae9588617e8f3bce662a0ba2d60796b559a420b44783a
│ │ ├── f6
│ │ │ └── c7
│ │ │ └── c2aee6453a94a772577d770a438f34805af27cbf0c7a776b19d6850307b5
│ │ ├── f9
│ │ │ └── 82
│ │ │ └── 228120d240455dd412cb68cbe2007319fbf91d96bb998e7f24c45faadc0b
│ │ ├── fa
│ │ │ ├── 88
│ │ │ │ └── 31cbd6ca584e75edf3642c6f8b079c1f2b5eca1d7b2780ce2e86c24f1e84
│ │ │ └── a1
│ │ │ └── dd9e9a25a0a13875f496dfc7b415ddc641f6b30648050accc001be4635ee
│ │ ├── fb
│ │ │ └── fc
│ │ │ └── 6282476d454ca3b17e0ba6cf70a4b6a87142bd8f3139517d572b2f9911a4
│ │ ├── fc
│ │ │ └── ee
│ │ │ └── fc3e1dd6706bd557d2840d92ff10cdd6928b92fb8c46d2195dfbd8d4b2be
│ │ ├── fd
│ │ │ └── 60
│ │ │ └── 528c5445a438483b66270e6a4dddfa6e9bdcceb2b998cb6f7580d23ceb1b
│ │ └── ff
│ │ ├── 9f
│ │ │ └── 48b5354df0d5feb3420245101c38efe5fb13f171ce2093c16eeb4ba41c7e
│ │ └── d6
│ │ └── 9ea5f7eac400baceca422723dd933d7c505c100130f066f787943d1ac679
│ └── _update-notifier-last-checked
├── .pre-commit-config.yaml
├── .pre-commit-setup.md
├── .prettierrc.json
├── .tmp
│ └── temp-1758247471070.ts
├── archive
│ └── ebook
│ └── enterprise_architecture_mcp_ebook.pdf
├── async-fix-verification-summary.md
├── CHANGELOG.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── custom
│ ├── dir
│ │ └── adr-0001-complete-decision.md
│ └── research
│ ├── dir
│ │ └── perform_research_test_research_001.md
│ └── README.md
├── debug_test.js
├── docker-compose.docs.yml
├── docs
│ ├── .dockerignore
│ ├── .gitignore
│ ├── .vitepress
│ │ └── config.js
│ ├── adrs
│ │ ├── adr-0001-integration-test-decision.md
│ │ ├── adr-0001-test-decision.md
│ │ ├── adr-001-mcp-protocol-implementation-strategy.md
│ │ ├── adr-002-ai-integration-and-advanced-prompting-strategy.md
│ │ ├── adr-003-memory-centric-architecture.md
│ │ ├── adr-004-security-and-content-masking-strategy.md
│ │ ├── adr-005-testing-and-quality-assurance-strategy.md
│ │ ├── adr-006-tree-sitter-integration-strategy.md
│ │ ├── adr-007-cicd-pipeline-strategy.md
│ │ ├── adr-008-development-workflow-strategy.md
│ │ ├── adr-009-package-distribution-strategy.md
│ │ └── README.md
│ ├── api-styles.css
│ ├── CODE_OF_CONDUCT.md
│ ├── community
│ │ ├── .github
│ │ │ ├── ISSUE_TEMPLATE
│ │ │ │ ├── bug_report.yml
│ │ │ │ └── feature_request.yml
│ │ │ └── PULL_REQUEST_TEMPLATE.md
│ │ ├── CODE_OF_CONDUCT.md
│ │ ├── CONTRIBUTING.md
│ │ ├── README-library.md
│ │ └── SECURITY.md
│ ├── configuration.md
│ ├── CONTRIBUTING.md
│ ├── CONVERSION_CHECKLIST.md
│ ├── DEPENDABOT.md
│ ├── DEPLOYMENT_GUIDE.md
│ ├── development.md
│ ├── diataxis-index.md
│ ├── DOCKER_SETUP.md
│ ├── DOCKER_TEST_SUCCESS.txt
│ ├── docker-compose.yml
│ ├── Dockerfile
│ ├── DOCUMENTATION_IMPROVEMENT_PLAN.md
│ ├── DOCUMENTATION-UPDATE-PLAN.md
│ ├── DOCUSAURUS_MIGRATION.md
│ ├── DOCUSAURUS_QUICKSTART.md
│ ├── docusaurus.config.js
│ ├── explanation
│ │ ├── adr-philosophy.md
│ │ ├── ai-architecture-concepts.md
│ │ ├── ai-workflow-concepts.md
│ │ ├── ape-framework-design.md
│ │ ├── architecture-overview.md
│ │ ├── context-file-tool-coverage.md
│ │ ├── index.md
│ │ ├── knowledge-generation-framework-design.md
│ │ ├── knowledge-graph.md
│ │ ├── mcp-architecture-flow.md
│ │ ├── mcp-concepts.md
│ │ ├── performance-design.md
│ │ ├── prompt-engineering.md
│ │ ├── reflexion-framework-design.md
│ │ ├── security-philosophy.md
│ │ ├── self-learning-architecture.md
│ │ ├── server-architecture.md
│ │ └── tool-design.md
│ ├── how-to
│ │ ├── deploy-to-production.md
│ │ └── index.md
│ ├── how-to-guides
│ │ ├── ape-implementation-strategy.md
│ │ ├── ape-usage-guide.md
│ │ ├── bootstrap-architecture-docs.md
│ │ ├── cicd-integration.md
│ │ ├── contribute.md
│ │ ├── custom-rules.md
│ │ ├── deploy-your-own-server.md
│ │ ├── deployment-readiness.md
│ │ ├── firecrawl-setup.md
│ │ ├── generate-adrs-from-prd.md
│ │ ├── getting-started-workflow-guidance.md
│ │ ├── installation-guide.md
│ │ ├── interactive-adr-planning.md
│ │ ├── knowledge-generation-usage-guide.md
│ │ ├── large-team-scaling.md
│ │ ├── llm-context-file-configuration.md
│ │ ├── mcp-client-compatibility.md
│ │ ├── migrate-existing-adrs.md
│ │ ├── performance-testing.md
│ │ ├── prd-to-adrs.md
│ │ ├── progress-tracking.md
│ │ ├── prompting-guide.md
│ │ ├── reflexion-implementation-strategy.md
│ │ ├── reflexion-usage-guide.md
│ │ ├── research-integration.md
│ │ ├── security-analysis.md
│ │ ├── server-context-file.md
│ │ ├── testing-guide.md
│ │ ├── tool-development.md
│ │ ├── troubleshooting.md
│ │ └── work-with-existing-adrs.md
│ ├── ide-rules
│ │ ├── additional-workflows.md
│ │ ├── command-structure.md
│ │ ├── environment-validation-workflow.md
│ │ ├── ide-specific
│ │ │ ├── cursor
│ │ │ │ └── cursor-rules-template.md
│ │ │ ├── jetbrains
│ │ │ │ └── jetbrains-rules-template.md
│ │ │ ├── vscode
│ │ │ │ └── vscode-rules-template.md
│ │ │ └── windsurf
│ │ │ └── windsurf-rules-template.md
│ │ ├── quickstart-guide.md
│ │ ├── README.md
│ │ ├── standalone-usage.md
│ │ └── universal-workflows.md
│ ├── index.md
│ ├── LOGO_DESIGN_PROMPT.md
│ ├── Makefile
│ ├── mcp-planning-tool-usage.md
│ ├── MIGRATION_GUIDE.md
│ ├── nginx.conf
│ ├── notes
│ │ ├── DEVELOPER_GUIDANCE.md
│ │ ├── knowledge-graph.md
│ │ ├── media
│ │ │ ├── 01-first-steps.md
│ │ │ ├── diataxis-index.md
│ │ │ ├── install-rhel.sh
│ │ │ ├── LICENSE
│ │ │ ├── mcp-client-config.md
│ │ │ ├── mcp-concepts.md
│ │ │ ├── performance-design.md
│ │ │ ├── security-philosophy.md
│ │ │ └── troubleshooting.md
│ │ ├── performance-design.md
│ │ ├── prompt-engineering.md
│ │ ├── README.md
│ │ ├── RESEARCH-DRIVEN-ARCHITECTURE.md
│ │ ├── RESEARCH-DRIVEN-INTEGRATION-ANALYSIS.md
│ │ ├── research-driven-workflow.md
│ │ ├── research-integration.md
│ │ ├── technical-debt
│ │ │ └── LINT_CLEANUP_PLAN.md
│ │ ├── tool-design.md
│ │ └── USER_GUIDANCE.md
│ ├── package-lock.json
│ ├── package.json
│ ├── public
│ │ └── logo.png
│ ├── QUICK_START.md
│ ├── README_SCRIPTS.md
│ ├── README-library.md
│ ├── README.md
│ ├── reference
│ │ ├── analysis-tools.md
│ │ ├── api-documentation.md
│ │ ├── api-reference-updated.md
│ │ ├── api-reference.md
│ │ ├── comprehensive-api-reference.md
│ │ ├── environment-config.md
│ │ ├── generation-tools.md
│ │ ├── index.md
│ │ ├── mcp-client-config.md
│ │ ├── security-tools.md
│ │ ├── usage-examples.md
│ │ └── validation-tools.md
│ ├── release-dashboard.md
│ ├── research
│ │ ├── perform_research_research_000.md
│ │ ├── perform_research_research_001.md
│ │ ├── perform_research_research_002.md
│ │ ├── perform_research_research_003.md
│ │ ├── perform_research_research_004.md
│ │ ├── perform_research_research_005.md
│ │ ├── perform_research_research_006.md
│ │ ├── perform_research_research_007.md
│ │ ├── perform_research_research_008.md
│ │ ├── perform_research_research_009.md
│ │ ├── perform_research_research_010.md
│ │ ├── perform_research_research_011.md
│ │ ├── perform_research_research_012.md
│ │ ├── perform_research_research_013.md
│ │ ├── perform_research_research_014.md
│ │ ├── perform_research_research_015.md
│ │ ├── perform_research_research_016.md
│ │ ├── perform_research_research_017.md
│ │ ├── perform_research_research_018.md
│ │ ├── perform_research_research_019.md
│ │ ├── perform_research_research_020.md
│ │ ├── perform_research_research_021.md
│ │ ├── perform_research_research_022.md
│ │ ├── perform_research_research_023.md
│ │ ├── perform_research_research_024.md
│ │ ├── perform_research_research_025.md
│ │ ├── perform_research_research_026.md
│ │ ├── perform_research_research_027.md
│ │ ├── perform_research_research_028.md
│ │ ├── perform_research_research_029.md
│ │ ├── perform_research_research_030.md
│ │ ├── perform_research_research_031.md
│ │ ├── perform_research_research_032.md
│ │ ├── perform_research_research_033.md
│ │ ├── perform_research_research_034.md
│ │ ├── perform_research_research_035.md
│ │ ├── perform_research_research_036.md
│ │ ├── perform_research_research_037.md
│ │ ├── perform_research_research_038.md
│ │ ├── perform_research_research_039.md
│ │ ├── perform_research_research_040.md
│ │ ├── perform_research_research_041.md
│ │ ├── perform_research_research_042.md
│ │ ├── perform_research_research_043.md
│ │ ├── perform_research_research_044.md
│ │ ├── perform_research_research_045.md
│ │ ├── perform_research_research_046.md
│ │ ├── perform_research_research_047.md
│ │ ├── perform_research_research_048.md
│ │ ├── perform_research_research_049.md
│ │ ├── perform_research_test_research__________001.md
│ │ ├── perform_research_test_research_001.md
│ │ ├── perform_research_test_research_002.md
│ │ ├── perform_research_test_unicode.md
│ │ └── README.md
│ ├── SECURITY.md
│ ├── setup-docusaurus.sh
│ ├── setup-website.sh
│ ├── sidebars.js
│ ├── sitemap.xml
│ ├── src
│ │ └── css
│ │ └── custom.css
│ ├── static
│ │ └── img
│ │ ├── logo.png
│ │ └── og-image.png
│ ├── technical.md
│ ├── TESTING_GUIDE.md
│ ├── TODO_MANAGEMENT_FIX.md
│ ├── tsconfig.json
│ ├── tutorials
│ │ ├── 01-first-steps.md
│ │ ├── 02-existing-projects.md
│ │ ├── 03-advanced-analysis.md
│ │ ├── index.md
│ │ ├── security-focused-workflow.md
│ │ └── team-collaboration.md
│ ├── VERSION_MANAGEMENT.md
│ └── WEBSITE_SETUP.md
├── eslint.config.js
├── jest.config.js
├── LICENSE
├── LLM_CONTEXT.md
├── Makefile
├── mcp-inspector-config.json
├── mcp-test-results.json
├── package-lock.json
├── package.json
├── README.md
├── RELEASE_NOTES_v2.0.22.md
├── reports
│ ├── comprehensive-validation_20251003_185155.json
│ ├── link-summary_20251003_185121.json
│ ├── link-validation_20250922_151241.txt
│ ├── link-validation_20250922_151242.txt
│ ├── link-validation_20251003_184136.txt
│ ├── link-validation_20251003_184141.txt
│ ├── link-validation_20251003_184945.txt
│ ├── link-validation_20251003_185000.txt
│ ├── link-validation_20251003_185121.txt
│ └── markdown-validation_20251003_185155.txt
├── sample-project
│ ├── docs
│ │ └── adrs
│ │ ├── 001-database-architecture.md
│ │ ├── 002-api-authentication.md
│ │ └── 003-legacy-data-migration.md
│ └── README.md
├── scripts
│ ├── ai-release-notes.ts
│ ├── check-docs-links.sh
│ ├── check-duplicate-links.ts
│ ├── cleanup-template-docs.sh
│ ├── docs-workflow.sh
│ ├── fix-broken-links.py
│ ├── fix-docs-accuracy.sh
│ ├── fix-docs-content-accuracy.sh
│ ├── install-rhel.sh
│ ├── pre-commit-check.sh
│ ├── pre-commit-checklist.sh
│ ├── remove-duplicate-docs.sh
│ ├── sync-tags-to-npm.sh
│ ├── test-advanced-prompting.sh
│ ├── test-infrastructure.sh
│ ├── test-mcp-functionality.sh
│ ├── test-mcp-logging.ts
│ ├── test-mcp-server.sh
│ ├── test-node-compatibility.js
│ ├── test-npm-package.sh
│ ├── test-release-integration.sh
│ ├── validate-build.js
│ ├── validate-docs.sh
│ └── validate-links-with-sitemap.ts
├── SECURITY.md
├── src
│ ├── config
│ │ └── ai-config.ts
│ ├── index.ts
│ ├── prompts
│ │ ├── adr-suggestion-prompts.ts
│ │ ├── analysis-prompts.ts
│ │ ├── deployment-analysis-prompts.ts
│ │ ├── environment-analysis-prompts.ts
│ │ ├── index.ts
│ │ ├── research-integration-prompts.ts
│ │ ├── research-question-prompts.ts
│ │ ├── rule-generation-prompts.ts
│ │ └── security-prompts.ts
│ ├── resources
│ │ ├── adr-by-id-resource.ts
│ │ ├── code-quality-resource.ts
│ │ ├── deployment-history-resource.ts
│ │ ├── deployment-status-resource.ts
│ │ ├── environment-analysis-resource.ts
│ │ ├── index.ts
│ │ ├── memory-snapshots-resource.ts
│ │ ├── pattern-by-name-resource.ts
│ │ ├── project-metrics-resource.ts
│ │ ├── project-status-resource.ts
│ │ ├── research-by-topic-resource.ts
│ │ ├── research-index-resource.ts
│ │ ├── resource-cache.ts
│ │ ├── resource-router.ts
│ │ ├── rule-by-id-resource.ts
│ │ ├── rule-catalog-resource.ts
│ │ ├── rule-generation-resource.ts
│ │ ├── technology-by-name-resource.ts
│ │ ├── todo-by-id-resource.ts
│ │ └── todo-list-resource.ts
│ ├── templates
│ │ └── domain-knowledge-templates.ts
│ ├── tools
│ │ ├── adr-bootstrap-validation-tool.ts
│ │ ├── adr-suggestion-tool.ts
│ │ ├── adr-validation-tool.ts
│ │ ├── bootstrap-validation-loop-tool.ts
│ │ ├── content-masking-tool.ts
│ │ ├── conversation-memory-tool.ts
│ │ ├── deployment-analysis-tool.ts
│ │ ├── deployment-guidance-tool.ts
│ │ ├── deployment-readiness-tool.ts
│ │ ├── environment-analysis-tool.ts
│ │ ├── expand-analysis-tool.ts
│ │ ├── get-server-context-tool.ts
│ │ ├── interactive-adr-planning-tool.ts
│ │ ├── llm-cloud-management-tool.ts
│ │ ├── llm-database-management-tool.ts
│ │ ├── llm-web-search-tool.ts
│ │ ├── mcp-planning-tool.ts
│ │ ├── memory-loading-tool.ts
│ │ ├── perform-research-tool.ts
│ │ ├── research-integration-tool.ts
│ │ ├── research-question-tool.ts
│ │ ├── review-existing-adrs-tool.ts
│ │ ├── rule-generation-tool.ts
│ │ ├── smart-git-push-tool-v2.ts
│ │ ├── smart-git-push-tool.ts
│ │ ├── tool-chain-orchestrator.ts
│ │ └── troubleshoot-guided-workflow-tool.ts
│ ├── types
│ │ ├── ape-framework.ts
│ │ ├── conversation-context.ts
│ │ ├── conversation-memory.ts
│ │ ├── enhanced-errors.ts
│ │ ├── index.ts
│ │ ├── knowledge-generation.ts
│ │ ├── knowledge-graph-schemas.ts
│ │ ├── memory-entities.ts
│ │ ├── reflexion-framework.ts
│ │ ├── state-reinforcement.ts
│ │ ├── tiered-response.ts
│ │ ├── tool-arguments.ts
│ │ └── tool-context.ts
│ └── utils
│ ├── actual-file-operations.ts
│ ├── adr-discovery.ts
│ ├── adr-knowledge-initializer.ts
│ ├── adr-suggestions.ts
│ ├── ai-executor.ts
│ ├── apply-cot-enhancement.ts
│ ├── automatic-prompt-engineering.ts
│ ├── cache.ts
│ ├── chain-of-thought-template.ts
│ ├── conditional-request.ts
│ ├── config.ts
│ ├── content-masking.ts
│ ├── conversation-memory-manager.ts
│ ├── deployment-analysis.ts
│ ├── deployment-type-registry.ts
│ ├── directory-compat.ts
│ ├── dynamic-deployment-intelligence.ts
│ ├── enhanced-logging.ts
│ ├── environment-analysis.ts
│ ├── environment-capability-registry.ts
│ ├── file-system.ts
│ ├── file-system.ts.backup
│ ├── gitleaks-detector.ts
│ ├── index.ts
│ ├── interactive-approval.ts
│ ├── json-safe.ts
│ ├── knowledge-generation.ts
│ ├── knowledge-graph-manager.ts
│ ├── llm-artifact-detector.ts
│ ├── location-filter.ts
│ ├── mcp-response-validator.ts
│ ├── memory-entity-manager.ts
│ ├── memory-health-scoring.ts
│ ├── memory-migration-manager.ts
│ ├── memory-relationship-mapper.ts
│ ├── memory-rollback-manager.ts
│ ├── memory-transformation.ts
│ ├── monitoring.ts
│ ├── output-masking.ts
│ ├── prompt-composition.ts
│ ├── prompt-execution.ts
│ ├── reflexion.ts
│ ├── release-readiness-detector.ts
│ ├── research-documentation.ts
│ ├── research-integration.ts
│ ├── research-orchestrator.ts
│ ├── research-questions.ts
│ ├── resource-versioning.ts
│ ├── ripgrep-wrapper.ts
│ ├── root-manager.ts
│ ├── rule-format.ts
│ ├── rule-generation.ts
│ ├── server-context-generator.ts
│ ├── state-reinforcement-manager.ts
│ ├── tiered-response-manager.ts
│ └── tree-sitter-analyzer.ts
├── test-results
│ └── junit.xml
├── tests
│ ├── __mocks__
│ │ ├── @tree-sitter-grammars
│ │ │ └── tree-sitter-hcl.ts
│ │ ├── tree-sitter-bash.ts
│ │ ├── tree-sitter-dockerfile.ts
│ │ ├── tree-sitter-javascript.ts
│ │ ├── tree-sitter-json.ts
│ │ ├── tree-sitter-python.ts
│ │ ├── tree-sitter-typescript.ts
│ │ ├── tree-sitter-yaml.ts
│ │ └── tree-sitter.ts
│ ├── ape.test.ts
│ ├── cache-architecture-analysis.md
│ ├── cache.test.ts
│ ├── config
│ │ └── ai-config.test.ts
│ ├── config.test.ts
│ ├── index.test.ts
│ ├── integration
│ │ ├── memory-migration-integration.test.ts
│ │ ├── memory-migration-simple.test.ts
│ │ ├── memory-system-integration.test.ts
│ │ └── smart-code-linking.test.ts
│ ├── knowledge-generation.test.ts
│ ├── mcp-server.test.ts
│ ├── performance
│ │ └── memory-performance.test.ts
│ ├── performance-effectiveness.test.ts
│ ├── prompts
│ │ ├── deployment-analysis-prompts.test.ts
│ │ ├── environment-analysis-prompts.test.ts
│ │ ├── research-integration-prompts.test.ts
│ │ ├── research-question-prompts.test.ts
│ │ ├── rule-generation-prompts.test.ts
│ │ └── security-prompts.test.ts
│ ├── README.md
│ ├── reflexion.test.ts
│ ├── research-integration-tool.test.ts
│ ├── research-question-tool.test.ts
│ ├── resources
│ │ ├── code-quality-resource.test.ts
│ │ └── deployment-history-resource.test.ts
│ ├── setup.ts
│ ├── smart-git-push-release-readiness.test.ts
│ ├── smart-git-push-v2.test.ts
│ ├── smart-git-push.test.ts
│ ├── smoke.test.ts
│ ├── templates
│ │ └── domain-knowledge-templates.test.ts
│ ├── tools
│ │ ├── adr-bootstrap-validation-tool.test.ts
│ │ ├── adr-suggestion-tool.test.ts
│ │ ├── adr-validation-tool.test.ts
│ │ ├── content-masking-tool.test.ts
│ │ ├── deployment-analysis-tool.test.ts
│ │ ├── deployment-guidance-tool.test.ts
│ │ ├── deployment-readiness-tool.test.ts
│ │ ├── environment-analysis-tool.test.ts
│ │ ├── interactive-adr-planning-tool.test.ts
│ │ ├── mcp-planning-tool.test.ts
│ │ ├── memory-loading-tool.test.ts
│ │ ├── perform-research-tool.test.ts
│ │ ├── perform-research-tool.test.ts.backup
│ │ ├── research-integration-tool.test.ts
│ │ ├── review-existing-adrs-tool.test.ts
│ │ ├── rule-generation-tool.test.ts
│ │ ├── smart-git-push-tool-v2.test.ts
│ │ ├── smart-git-push-tool.test.ts
│ │ ├── tool-chain-orchestrator.test.ts
│ │ └── troubleshoot-guided-workflow-tool.test.ts
│ ├── types
│ │ └── conversation-context.test.ts
│ ├── types.test.ts
│ ├── utils
│ │ ├── adr-knowledge-initializer.test.ts
│ │ ├── advanced-prompting-test-utils.ts
│ │ ├── ai-executor.test.ts
│ │ ├── conditional-request.test.ts
│ │ ├── deployment-analysis.test.ts
│ │ ├── environment-capability-registry.test.ts
│ │ ├── file-system.test.ts
│ │ ├── find-related-code.test.ts
│ │ ├── gitleaks-detector.test.ts
│ │ ├── interactive-approval.test.ts
│ │ ├── llm-artifact-detector.test.ts
│ │ ├── location-filter.test.ts
│ │ ├── mcp-response-validator.test.ts
│ │ ├── memory-entity-manager.test.ts
│ │ ├── memory-relationship-mapper.test.ts
│ │ ├── memory-rollback-manager.test.ts
│ │ ├── memory-transformation.test.ts
│ │ ├── monitoring-smoke.test.ts
│ │ ├── monitoring.test.ts
│ │ ├── output-masking.test.ts
│ │ ├── prompt-composition.test.ts
│ │ ├── prompt-execution.test.ts
│ │ ├── release-readiness-detector.test.ts
│ │ ├── research-documentation.test.ts
│ │ ├── research-integration.test.ts
│ │ ├── research-orchestrator.test.ts
│ │ ├── research-questions.test.ts
│ │ ├── resource-versioning.test.ts
│ │ ├── rule-format.test.ts
│ │ ├── rule-generation.test.ts
│ │ ├── test-config.ts
│ │ ├── test-helpers.test.ts
│ │ ├── test-helpers.ts
│ │ ├── test-infrastructure.test.ts
│ │ ├── test-infrastructure.ts
│ │ ├── tree-sitter-analyzer.test.ts
│ │ └── tree-sitter-jest-integration.test.ts
│ └── version.test.ts
├── tsconfig.json
└── typedoc.json
```
# Files
--------------------------------------------------------------------------------
/src/index.ts:
--------------------------------------------------------------------------------
```typescript
#!/usr/bin/env node
/**
* MCP ADR Analysis Server
* Main entry point for the Model Context Protocol server
*
* This server provides Tools, Resources, and Prompts for analyzing
* Architectural Decision Records and project architecture.
*/
import { Server } from '@modelcontextprotocol/sdk/server/index.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import {
CallToolRequestSchema,
ListToolsRequestSchema,
ListResourcesRequestSchema,
ReadResourceRequestSchema,
ListPromptsRequestSchema,
GetPromptRequestSchema,
type CallToolResult,
} from '@modelcontextprotocol/sdk/types.js';
import { readFileSync } from 'fs';
import { join } from 'path';
import { getCurrentDirCompat } from './utils/directory-compat.js';
import { McpAdrError } from './types/index.js';
import { CONVERSATION_CONTEXT_SCHEMA } from './types/conversation-context.js';
import {
maskMcpResponse,
createMaskingConfig,
type MaskingConfig,
} from './utils/output-masking.js';
import {
loadConfig,
validateProjectPath,
createLogger,
printConfigSummary,
type ServerConfig,
} from './utils/config.js';
import { KnowledgeGraphManager } from './utils/knowledge-graph-manager.js';
import { StateReinforcementManager } from './utils/state-reinforcement-manager.js';
import { ConversationMemoryManager } from './utils/conversation-memory-manager.js';
import { MemoryEntityManager } from './utils/memory-entity-manager.js';
import { RootManager } from './utils/root-manager.js';
import { ServerContextGenerator } from './utils/server-context-generator.js';
import { type ToolContext, createNoOpContext } from './types/tool-context.js';
import {
type GetWorkflowGuidanceArgs,
type GetArchitecturalContextArgs,
type GetDevelopmentGuidanceArgs,
type GenerateAdrFromDecisionArgs,
type ValidateRulesArgs,
type CreateRuleSetArgs,
type ToolChainOrchestratorArgs,
type ReadFileArgs,
type WriteFileArgs,
type AnalyzeProjectEcosystemArgs,
type ArchitecturalDomain,
type AnalyzeContentSecurityArgs,
type GenerateContentMaskingArgs,
type ConfigureCustomPatternsArgs,
type ApplyBasicContentMaskingArgs,
type ValidateContentMaskingArgs,
type ActionArgs,
type TodoManagementV2Args,
type GenerateArchitecturalKnowledgeFunction,
type ExecuteWithReflexionFunction,
type RetrieveRelevantMemoriesFunction,
type CreateToolReflexionConfigFunction,
} from './types/tool-arguments.js';
/**
* Get version from package.json
*/
function getPackageVersion(): string {
try {
// Handle both Jest environment and normal execution
const currentDir = getCurrentDirCompat();
// Strategy 1: Try multiple possible locations for package.json
const possiblePaths = [
join(currentDir, 'package.json'),
join(currentDir, '..', 'package.json'),
join(currentDir, '..', '..', 'package.json'),
join(process.cwd(), 'package.json'),
];
for (const packageJsonPath of possiblePaths) {
try {
const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf-8'));
if (packageJson.name === 'mcp-adr-analysis-server') {
return packageJson.version;
}
} catch {
// Try next path
}
}
// Strategy 2: Use process.env.npm_package_version if available (during npm scripts)
if (process.env['npm_package_version']) {
return process.env['npm_package_version'];
}
// Final fallback: Use generic version instead of hardcoded specific version
// This prevents the need to update this code when version changes
return 'unknown'; // Generic fallback - no longer tied to specific version
} catch (error) {
console.error('Error reading package.json:', error);
return 'unknown'; // Generic fallback - no longer tied to specific version
}
}
/**
* Server configuration
*/
const SERVER_INFO = {
name: 'mcp-adr-analysis-server',
version: getPackageVersion(),
description: 'MCP server for analyzing Architectural Decision Records and project architecture',
};
/**
* Main server class
*/
export class McpAdrAnalysisServer {
private server: Server;
private maskingConfig: MaskingConfig;
private config: ServerConfig;
private logger: ReturnType<typeof createLogger>;
private kgManager: KnowledgeGraphManager;
private stateReinforcementManager: StateReinforcementManager;
private conversationMemoryManager: ConversationMemoryManager;
private memoryEntityManager: MemoryEntityManager;
private rootManager: RootManager;
private contextGenerator: ServerContextGenerator;
constructor() {
// Load and validate configuration
this.config = loadConfig();
this.logger = createLogger(this.config);
this.kgManager = new KnowledgeGraphManager();
this.stateReinforcementManager = new StateReinforcementManager(this.kgManager);
this.conversationMemoryManager = new ConversationMemoryManager(this.kgManager);
this.memoryEntityManager = new MemoryEntityManager();
// Initialize root manager for file access control
this.rootManager = new RootManager(this.config.projectPath, this.config.adrDirectory);
// Initialize server context generator
this.contextGenerator = new ServerContextGenerator();
// Print configuration summary
printConfigSummary(this.config);
// Note: Validation will be done during startup
this.server = new Server(SERVER_INFO, {
capabilities: {
tools: {},
resources: {},
prompts: {},
},
});
this.maskingConfig = createMaskingConfig();
this.setupHandlers();
}
/**
* Validate configuration and project setup
*/
private async validateConfiguration(): Promise<void> {
try {
await validateProjectPath(this.config.projectPath);
this.logger.info(`Project path validated: ${this.config.projectPath}`);
} catch (error: unknown) {
const errorMessage = error instanceof Error ? error.message : String(error);
this.logger.error(`Configuration validation failed: ${errorMessage}`);
throw error;
}
}
/**
* Public health check method for testing
*/
async healthCheck(): Promise<void> {
await this.validateConfiguration();
this.logger.info('Health check completed successfully');
}
/**
* Setup MCP protocol handlers
*
* @description Configures all Model Context Protocol request handlers for the ADR Analysis Server.
* Implements the complete MCP specification including tools, resources, and prompts.
*
* @private
* @since 2.0.0
* @category MCP Protocol
*/
private setupHandlers(): void {
/**
* List Tools Handler - MCP Protocol Endpoint
*
* @description Returns the complete catalog of available tools for ADR analysis,
* research, validation, and deployment operations. Each tool includes comprehensive
* input schemas and descriptions for client integration.
*
* @returns {Promise<{tools: Array}>} Complete tool catalog with schemas
*
* @example
* ```typescript
* // MCP Client usage
* const tools = await mcpClient.listTools();
* console.log(tools.tools.length); // 20+ available tools
*
* // Find specific tool
* const researchTool = tools.tools.find(t => t.name === 'perform_research');
* console.log(researchTool.description); // Tool description
* ```
*
* @mcp-endpoint
* @category Tools
*/
this.server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: [
{
name: 'analyze_project_ecosystem',
description:
'Comprehensive recursive project ecosystem analysis with advanced prompting techniques (Knowledge Generation + Reflexion)',
inputSchema: {
type: 'object',
properties: {
projectPath: {
type: 'string',
description:
'Path to the project directory to analyze (optional, uses configured PROJECT_PATH if not provided)',
},
includePatterns: {
type: 'array',
items: { type: 'string' },
description: 'File patterns to include in analysis',
},
enhancedMode: {
type: 'boolean',
description:
'Enable advanced prompting features (Knowledge Generation + Reflexion)',
default: true,
},
knowledgeEnhancement: {
type: 'boolean',
description: 'Enable Knowledge Generation for technology-specific insights',
default: true,
},
learningEnabled: {
type: 'boolean',
description: 'Enable Reflexion learning from past analysis outcomes',
default: true,
},
technologyFocus: {
type: 'array',
items: { type: 'string' },
description:
'Specific technologies to focus analysis on (auto-detected if not provided)',
},
analysisDepth: {
type: 'string',
enum: ['basic', 'detailed', 'comprehensive'],
description: 'Depth of ecosystem analysis',
default: 'comprehensive',
},
includeEnvironment: {
type: 'boolean',
description:
'Automatically include comprehensive environment analysis (default: true)',
default: true,
},
recursiveDepth: {
type: 'string',
description: 'Depth of recursive project analysis',
enum: ['shallow', 'moderate', 'deep', 'comprehensive'],
default: 'comprehensive',
},
analysisScope: {
type: 'array',
items: { type: 'string' },
description:
'Specific analysis areas to focus on (e.g., ["security", "performance", "architecture", "dependencies"])',
},
conversationContext: CONVERSATION_CONTEXT_SCHEMA,
},
required: [],
},
},
{
name: 'get_architectural_context',
description:
'Get detailed architectural context for specific files or the entire project, automatically sets up ADR infrastructure if missing, and provides outcome-focused workflow for project success',
inputSchema: {
type: 'object',
properties: {
filePath: {
type: 'string',
description:
'Specific file path to analyze (optional, analyzes entire project if not provided)',
},
includeCompliance: {
type: 'boolean',
description: 'Include compliance checks in the analysis',
default: true,
},
conversationContext: CONVERSATION_CONTEXT_SCHEMA,
},
},
},
{
name: 'generate_adrs_from_prd',
description:
'Generate Architectural Decision Records from a Product Requirements Document with advanced prompting techniques (APE + Knowledge Generation)',
inputSchema: {
type: 'object',
properties: {
prdPath: {
type: 'string',
description: 'Path to the PRD.md file',
},
outputDirectory: {
type: 'string',
description:
'Directory to output generated ADRs (optional, uses configured ADR_DIRECTORY if not provided)',
},
enhancedMode: {
type: 'boolean',
description: 'Enable advanced prompting features (APE + Knowledge Generation)',
default: true,
},
promptOptimization: {
type: 'boolean',
description: 'Enable Automatic Prompt Engineering for optimized ADR generation',
default: true,
},
knowledgeEnhancement: {
type: 'boolean',
description: 'Enable Knowledge Generation for domain-specific insights',
default: true,
},
prdType: {
type: 'string',
enum: [
'web-application',
'mobile-app',
'microservices',
'data-platform',
'api-service',
'general',
],
description: 'Type of PRD for optimized knowledge generation',
default: 'general',
},
conversationContext: CONVERSATION_CONTEXT_SCHEMA,
},
required: ['prdPath'],
},
},
{
name: 'compare_adr_progress',
description:
'Compare TODO.md progress against ADRs and current environment to validate implementation status',
inputSchema: {
type: 'object',
properties: {
todoPath: {
type: 'string',
description: 'Path to TODO.md file to analyze',
default: 'TODO.md',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
projectPath: {
type: 'string',
description: 'Path to project root for environment analysis',
default: '.',
},
environment: {
type: 'string',
enum: ['development', 'staging', 'production', 'testing', 'auto-detect'],
description:
'Target environment context for validation (auto-detect will infer from project structure)',
default: 'auto-detect',
},
environmentConfig: {
type: 'object',
description: 'Environment-specific configuration and requirements',
properties: {
requiredFiles: {
type: 'array',
items: { type: 'string' },
description: 'Files required for this environment',
},
requiredServices: {
type: 'array',
items: { type: 'string' },
description: 'Services that must be implemented for this environment',
},
securityLevel: {
type: 'string',
enum: ['low', 'medium', 'high', 'critical'],
description: 'Required security level for this environment',
},
performanceRequirements: {
type: 'object',
description: 'Performance requirements for this environment',
},
},
},
validationType: {
type: 'string',
enum: ['full', 'todo-only', 'adr-only', 'environment-only'],
description: 'Type of validation to perform',
default: 'full',
},
includeFileChecks: {
type: 'boolean',
description: 'Include file existence and implementation checks',
default: true,
},
includeRuleValidation: {
type: 'boolean',
description: 'Include architectural rule compliance validation',
default: true,
},
deepCodeAnalysis: {
type: 'boolean',
description:
'Perform deep code analysis to distinguish mock from production implementations',
default: true,
},
functionalValidation: {
type: 'boolean',
description:
'Validate that code actually functions according to ADR goals, not just exists',
default: true,
},
strictMode: {
type: 'boolean',
description:
'Enable strict validation mode with reality-check mechanisms against overconfident assessments',
default: true,
},
environmentValidation: {
type: 'boolean',
description: 'Enable environment-specific validation rules and checks',
default: true,
},
},
},
},
{
name: 'analyze_content_security',
description:
'Analyze content for sensitive information using AI-powered detection with optional memory integration for security pattern learning',
inputSchema: {
type: 'object',
properties: {
content: {
type: 'string',
description: 'Content to analyze for sensitive information',
},
contentType: {
type: 'string',
enum: ['code', 'documentation', 'configuration', 'logs', 'general'],
description: 'Type of content being analyzed',
default: 'general',
},
userDefinedPatterns: {
type: 'array',
items: { type: 'string' },
description: 'User-defined sensitive patterns to detect',
},
enableMemoryIntegration: {
type: 'boolean',
description:
'Enable memory entity storage for security pattern learning and institutional knowledge building',
default: true,
},
knowledgeEnhancement: {
type: 'boolean',
description:
'Enable Generated Knowledge Prompting for security and privacy expertise',
default: true,
},
enhancedMode: {
type: 'boolean',
description: 'Enable advanced prompting features',
default: true,
},
},
required: ['content'],
},
},
{
name: 'generate_content_masking',
description: 'Generate masking instructions for detected sensitive content',
inputSchema: {
type: 'object',
properties: {
content: {
type: 'string',
description: 'Content to mask',
},
detectedItems: {
type: 'array',
items: {
type: 'object',
properties: {
type: { type: 'string' },
content: { type: 'string' },
startPosition: { type: 'number' },
endPosition: { type: 'number' },
severity: { type: 'string' },
},
},
description: 'Detected sensitive items to mask',
},
maskingStrategy: {
type: 'string',
enum: ['full', 'partial', 'placeholder', 'environment'],
description: 'Strategy for masking content',
default: 'full',
},
},
required: ['content', 'detectedItems'],
},
},
{
name: 'configure_custom_patterns',
description: 'Configure custom sensitive patterns for a project',
inputSchema: {
type: 'object',
properties: {
projectPath: {
type: 'string',
description: 'Path to the project directory',
},
existingPatterns: {
type: 'array',
items: { type: 'string' },
description: 'Existing patterns to consider',
},
},
required: ['projectPath'],
},
},
{
name: 'apply_basic_content_masking',
description: 'Apply basic content masking (fallback when AI is not available)',
inputSchema: {
type: 'object',
properties: {
content: {
type: 'string',
description: 'Content to mask',
},
maskingStrategy: {
type: 'string',
enum: ['full', 'partial', 'placeholder'],
description: 'Strategy for masking content',
default: 'full',
},
},
required: ['content'],
},
},
{
name: 'validate_content_masking',
description: 'Validate that content masking was applied correctly',
inputSchema: {
type: 'object',
properties: {
originalContent: {
type: 'string',
description: 'Original content before masking',
},
maskedContent: {
type: 'string',
description: 'Content after masking',
},
},
required: ['originalContent', 'maskedContent'],
},
},
{
name: 'manage_cache',
description: 'Manage MCP resource cache (clear, stats, cleanup)',
inputSchema: {
type: 'object',
properties: {
action: {
type: 'string',
enum: ['clear', 'stats', 'cleanup', 'invalidate'],
description: 'Cache management action to perform',
},
key: {
type: 'string',
description: 'Specific cache key to invalidate (for invalidate action)',
},
},
required: ['action'],
},
},
{
name: 'configure_output_masking',
description: 'Configure content masking for all MCP outputs',
inputSchema: {
type: 'object',
properties: {
enabled: {
type: 'boolean',
description: 'Enable or disable output masking',
},
strategy: {
type: 'string',
enum: ['full', 'partial', 'placeholder', 'environment'],
description: 'Masking strategy to use',
},
customPatterns: {
type: 'array',
items: { type: 'string' },
description: 'Custom patterns to mask',
},
action: {
type: 'string',
enum: ['get', 'set', 'reset'],
description: 'Configuration action',
default: 'get',
},
},
},
},
{
name: 'suggest_adrs',
description:
'Suggest architectural decisions with advanced prompting techniques (Knowledge Generation + Reflexion). TIP: Read @.mcp-server-context.md first for project history, patterns, and previous ADRs to ensure consistency.',
inputSchema: {
type: 'object',
properties: {
projectPath: {
type: 'string',
description: 'Path to the project directory',
default: '.',
},
analysisType: {
type: 'string',
enum: ['implicit_decisions', 'code_changes', 'comprehensive'],
description: 'Type of analysis to perform',
default: 'comprehensive',
},
beforeCode: {
type: 'string',
description: 'Code before changes (for code_changes analysis)',
},
afterCode: {
type: 'string',
description: 'Code after changes (for code_changes analysis)',
},
changeDescription: {
type: 'string',
description: 'Description of the changes (for code_changes analysis)',
},
commitMessages: {
type: 'array',
items: { type: 'string' },
description: 'Related commit messages (for code_changes analysis)',
},
existingAdrs: {
type: 'array',
items: { type: 'string' },
description: 'List of existing ADR titles to avoid duplication',
},
enhancedMode: {
type: 'boolean',
description:
'Enable advanced prompting features (Knowledge Generation + Reflexion)',
default: true,
},
learningEnabled: {
type: 'boolean',
description: 'Enable Reflexion learning from past experiences',
default: true,
},
knowledgeEnhancement: {
type: 'boolean',
description: 'Enable Knowledge Generation for domain-specific insights',
default: true,
},
conversationContext: CONVERSATION_CONTEXT_SCHEMA,
},
},
},
{
name: 'generate_adr_from_decision',
description:
'Generate a complete ADR from decision data. TIP: Reference @.mcp-server-context.md to align with existing architectural patterns and decisions.',
inputSchema: {
type: 'object',
properties: {
decisionData: {
type: 'object',
properties: {
title: { type: 'string', description: 'Decision title' },
context: { type: 'string', description: 'Decision context and problem' },
decision: { type: 'string', description: 'The architectural decision' },
consequences: { type: 'string', description: 'Decision consequences' },
alternatives: {
type: 'array',
items: { type: 'string' },
description: 'Alternative approaches considered',
},
evidence: {
type: 'array',
items: { type: 'string' },
description: 'Supporting evidence for the decision',
},
},
required: ['title', 'context', 'decision', 'consequences'],
},
templateFormat: {
type: 'string',
enum: ['nygard', 'madr', 'custom'],
description: 'ADR template format to use',
default: 'nygard',
},
existingAdrs: {
type: 'array',
items: { type: 'string' },
description: 'List of existing ADRs for numbering and references',
},
adrDirectory: {
type: 'string',
description: 'Directory where ADRs are stored',
default: 'docs/adrs',
},
},
required: ['decisionData'],
},
},
{
name: 'generate_adr_bootstrap',
description:
'Generate bootstrap.sh and validate_bootstrap.sh scripts to ensure deployed code follows ADR requirements',
inputSchema: {
type: 'object',
properties: {
projectPath: {
type: 'string',
description: 'Path to the project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory where ADRs are stored',
default: 'docs/adrs',
},
outputPath: {
type: 'string',
description: 'Directory where to generate scripts',
default: '.',
},
scriptType: {
type: 'string',
enum: ['bootstrap', 'validate', 'both'],
description: 'Which scripts to generate',
default: 'both',
},
includeTests: {
type: 'boolean',
description: 'Include test execution in bootstrap',
default: true,
},
includeDeployment: {
type: 'boolean',
description: 'Include deployment steps in bootstrap',
default: true,
},
customValidations: {
type: 'array',
items: { type: 'string' },
description: 'Custom validation commands to include',
},
conversationContext: CONVERSATION_CONTEXT_SCHEMA,
},
},
},
{
name: 'bootstrap_validation_loop',
description:
'Execute complete bootstrap validation loop with environment monitoring, auto-fixing, and ADR learning. Iteratively validates deployments against ADRs and updates ADRs with real-world deployment experience.',
inputSchema: {
type: 'object',
properties: {
projectPath: {
type: 'string',
description: 'Path to the project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory where ADRs are stored',
default: 'docs/adrs',
},
targetEnvironment: {
type: 'string',
enum: ['development', 'staging', 'production', 'testing'],
description: 'Target deployment environment',
default: 'development',
},
maxIterations: {
type: 'number',
description: 'Maximum validation/fix iterations',
default: 5,
},
autoFix: {
type: 'boolean',
description: 'Automatically fix bootstrap scripts based on failures',
default: true,
},
validateAfterFix: {
type: 'boolean',
description: 'Re-validate after applying auto-fixes',
default: true,
},
captureEnvironmentSnapshot: {
type: 'boolean',
description: 'Capture environment state during execution',
default: true,
},
updateAdrsWithLearnings: {
type: 'boolean',
description: 'Update ADRs with deployment learnings (non-sensitive)',
default: true,
},
conversationContext: CONVERSATION_CONTEXT_SCHEMA,
},
},
},
{
name: 'discover_existing_adrs',
description: 'Discover and catalog existing ADRs in the project',
inputSchema: {
type: 'object',
properties: {
adrDirectory: {
type: 'string',
description: 'Directory to search for ADRs',
default: 'docs/adrs',
},
includeContent: {
type: 'boolean',
description: 'Whether to include ADR content in analysis',
default: false,
},
},
},
},
{
name: 'review_existing_adrs',
description:
'Review existing ADRs against actual code implementation with cloud/DevOps expertise. TIP: After review, call get_server_context to update @.mcp-server-context.md with findings.',
inputSchema: {
type: 'object',
properties: {
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
projectPath: {
type: 'string',
description: 'Path to the project directory',
default: '.',
},
specificAdr: {
type: 'string',
description: 'Specific ADR filename or title to review (optional)',
},
analysisDepth: {
type: 'string',
enum: ['basic', 'detailed', 'comprehensive'],
description: 'Depth of analysis to perform',
default: 'detailed',
},
includeTreeSitter: {
type: 'boolean',
description: 'Use tree-sitter for enhanced code analysis',
default: true,
},
generateUpdatePlan: {
type: 'boolean',
description: 'Generate action plan for updating non-compliant ADRs',
default: true,
},
conversationContext: CONVERSATION_CONTEXT_SCHEMA,
},
},
},
{
name: 'validate_adr',
description:
'Validate an existing ADR against actual infrastructure reality using research-driven analysis. TIP: Compare findings against patterns in @.mcp-server-context.md for consistency checks.',
inputSchema: {
type: 'object',
properties: {
adrPath: {
type: 'string',
description: 'Path to the ADR file to validate (relative or absolute)',
},
projectPath: {
type: 'string',
description: 'Path to the project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
includeEnvironmentCheck: {
type: 'boolean',
description: 'Include live environment verification in validation',
default: true,
},
confidenceThreshold: {
type: 'number',
description: 'Minimum research confidence threshold (0-1)',
default: 0.6,
},
},
required: ['adrPath'],
},
},
{
name: 'validate_all_adrs',
description: 'Validate all ADRs in a directory against actual infrastructure reality',
inputSchema: {
type: 'object',
properties: {
projectPath: {
type: 'string',
description: 'Path to the project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
includeEnvironmentCheck: {
type: 'boolean',
description: 'Include live environment verification in validation',
default: true,
},
minConfidence: {
type: 'number',
description: 'Minimum research confidence for validation (0-1)',
default: 0.6,
},
},
},
},
{
name: 'incorporate_research',
description: 'Incorporate research findings into architectural decisions',
inputSchema: {
type: 'object',
properties: {
researchPath: {
type: 'string',
description: 'Path to research directory',
default: 'docs/research',
},
adrDirectory: {
type: 'string',
description: 'Path to ADR directory',
default: 'docs/adrs',
},
analysisType: {
type: 'string',
enum: [
'monitor',
'extract_topics',
'evaluate_impact',
'generate_updates',
'comprehensive',
],
description: 'Type of research analysis to perform',
default: 'comprehensive',
},
existingTopics: {
type: 'array',
items: { type: 'string' },
description: 'Previously identified research topics',
},
researchTopics: {
type: 'array',
items: {
type: 'object',
properties: {
id: { type: 'string' },
title: { type: 'string' },
category: { type: 'string' },
keyFindings: { type: 'array', items: { type: 'string' } },
relevanceScore: { type: 'number' },
},
},
description: 'Research topics for impact evaluation',
},
adrId: {
type: 'string',
description: 'ADR ID for update generation',
},
updateType: {
type: 'string',
enum: ['content', 'status', 'consequences', 'alternatives', 'deprecation'],
description: 'Type of ADR update to generate',
},
researchFindings: {
type: 'array',
items: {
type: 'object',
properties: {
finding: { type: 'string' },
evidence: { type: 'array', items: { type: 'string' } },
impact: { type: 'string' },
},
},
description: 'Research findings for update generation',
},
},
},
},
{
name: 'create_research_template',
description: 'Create a research template file for documenting findings',
inputSchema: {
type: 'object',
properties: {
title: {
type: 'string',
description: 'Title of the research',
},
category: {
type: 'string',
description: 'Research category',
default: 'general',
},
researchPath: {
type: 'string',
description: 'Path to research directory',
default: 'docs/research',
},
},
required: ['title'],
},
},
{
name: 'request_action_confirmation',
description: 'Request confirmation before applying research-based changes',
inputSchema: {
type: 'object',
properties: {
action: {
type: 'string',
description: 'Description of the action to be performed',
},
details: {
type: 'string',
description: 'Detailed information about the action',
},
impact: {
type: 'string',
enum: ['low', 'medium', 'high', 'critical'],
description: 'Impact level of the action',
default: 'medium',
},
},
required: ['action', 'details'],
},
},
{
name: 'generate_rules',
description: 'Generate architectural rules from ADRs and code patterns',
inputSchema: {
type: 'object',
properties: {
source: {
type: 'string',
enum: ['adrs', 'patterns', 'both'],
description: 'Source for rule generation',
default: 'both',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
projectPath: {
type: 'string',
description: 'Path to project for pattern analysis',
default: '.',
},
existingRules: {
type: 'array',
items: {
type: 'object',
properties: {
id: { type: 'string' },
name: { type: 'string' },
description: { type: 'string' },
},
},
description: 'Existing rules to avoid duplication',
},
outputFormat: {
type: 'string',
enum: ['json', 'yaml', 'both'],
description: 'Output format for rules',
default: 'json',
},
},
},
},
{
name: 'validate_rules',
description: 'Validate code against architectural rules',
inputSchema: {
type: 'object',
properties: {
filePath: {
type: 'string',
description: 'Path to file to validate',
},
fileContent: {
type: 'string',
description: 'Content to validate (alternative to filePath)',
},
fileName: {
type: 'string',
description: 'Name of file being validated (when using fileContent)',
},
rules: {
type: 'array',
items: {
type: 'object',
properties: {
id: { type: 'string' },
name: { type: 'string' },
description: { type: 'string' },
pattern: { type: 'string' },
severity: { type: 'string' },
message: { type: 'string' },
},
required: ['id', 'name', 'pattern', 'severity', 'message'],
},
description: 'Rules to validate against',
},
validationType: {
type: 'string',
enum: ['file', 'function', 'component', 'module'],
description: 'Type of validation to perform',
default: 'file',
},
reportFormat: {
type: 'string',
enum: ['summary', 'detailed', 'json'],
description: 'Format for validation report',
default: 'detailed',
},
},
required: ['rules'],
},
},
{
name: 'create_rule_set',
description: 'Create machine-readable rule set in JSON/YAML format',
inputSchema: {
type: 'object',
properties: {
name: {
type: 'string',
description: 'Name of the rule set',
},
description: {
type: 'string',
description: 'Description of the rule set',
default: 'Generated architectural rule set',
},
adrRules: {
type: 'array',
items: { type: 'object' },
description: 'Rules extracted from ADRs',
},
patternRules: {
type: 'array',
items: { type: 'object' },
description: 'Rules generated from code patterns',
},
rules: {
type: 'array',
items: { type: 'object' },
description: 'Additional rules to include',
},
outputFormat: {
type: 'string',
enum: ['json', 'yaml', 'both'],
description: 'Output format for rule set',
default: 'json',
},
author: {
type: 'string',
description: 'Author of the rule set',
default: 'MCP ADR Analysis Server',
},
},
required: ['name'],
},
},
{
name: 'analyze_environment',
description:
'Analyze environment context and provide optimization recommendations with optional memory integration for environment snapshot tracking',
inputSchema: {
type: 'object',
properties: {
projectPath: {
type: 'string',
description: 'Path to project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
analysisType: {
type: 'string',
enum: [
'specs',
'containerization',
'requirements',
'compliance',
'comprehensive',
],
description: 'Type of environment analysis to perform',
default: 'comprehensive',
},
currentEnvironment: {
type: 'object',
description: 'Current environment specifications (for compliance analysis)',
},
requirements: {
type: 'object',
description: 'Environment requirements (for compliance analysis)',
},
industryStandards: {
type: 'array',
items: { type: 'string' },
description: 'Industry standards to assess compliance against',
},
enableMemoryIntegration: {
type: 'boolean',
description:
'Enable memory entity storage for environment snapshot tracking and historical analysis',
default: true,
},
enableTrendAnalysis: {
type: 'boolean',
description:
'Enable analysis of environment changes over time using stored snapshots',
default: true,
},
},
},
},
{
name: 'generate_research_questions',
description:
'Generate context-aware research questions and create research tracking system',
inputSchema: {
type: 'object',
properties: {
analysisType: {
type: 'string',
enum: ['correlation', 'relevance', 'questions', 'tracking', 'comprehensive'],
description: 'Type of research analysis to perform',
default: 'comprehensive',
},
researchContext: {
type: 'object',
properties: {
topic: { type: 'string' },
category: { type: 'string' },
scope: { type: 'string' },
objectives: { type: 'array', items: { type: 'string' } },
constraints: { type: 'array', items: { type: 'string' } },
timeline: { type: 'string' },
},
description: 'Research context and objectives',
},
problems: {
type: 'array',
items: {
type: 'object',
properties: {
id: { type: 'string' },
description: { type: 'string' },
category: { type: 'string' },
severity: { type: 'string' },
context: { type: 'string' },
},
},
description: 'Problems to correlate with knowledge graph',
},
knowledgeGraph: {
type: 'object',
properties: {
technologies: { type: 'array', items: { type: 'object' } },
patterns: { type: 'array', items: { type: 'object' } },
adrs: { type: 'array', items: { type: 'object' } },
relationships: { type: 'array', items: { type: 'object' } },
},
description: 'Architectural knowledge graph',
},
relevantKnowledge: {
type: 'object',
properties: {
adrs: { type: 'array', items: { type: 'object' } },
patterns: { type: 'array', items: { type: 'object' } },
gaps: { type: 'array', items: { type: 'object' } },
opportunities: { type: 'array', items: { type: 'object' } },
},
description: 'Relevant knowledge for question generation',
},
researchQuestions: {
type: 'array',
items: {
type: 'object',
properties: {
id: { type: 'string' },
question: { type: 'string' },
type: { type: 'string' },
priority: { type: 'string' },
timeline: { type: 'string' },
methodology: { type: 'string' },
},
},
description: 'Research questions for task tracking',
},
currentProgress: {
type: 'array',
items: {
type: 'object',
properties: {
questionId: { type: 'string' },
status: { type: 'string' },
progress: { type: 'number' },
findings: { type: 'array', items: { type: 'string' } },
blockers: { type: 'array', items: { type: 'string' } },
},
},
description: 'Current research progress',
},
projectPath: {
type: 'string',
description: 'Path to project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
},
},
},
{
name: 'perform_research',
description:
'Perform research using cascading sources: project files → knowledge graph → environment resources → web search (fallback)',
inputSchema: {
type: 'object',
properties: {
question: {
type: 'string',
description: 'The research question to answer',
},
projectPath: {
type: 'string',
description: 'Path to project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
confidenceThreshold: {
type: 'number',
description: 'Minimum confidence threshold (0-1) before suggesting web search',
default: 0.6,
minimum: 0,
maximum: 1,
},
performWebSearch: {
type: 'boolean',
description: 'Enable web search recommendations when confidence is low',
default: true,
},
},
required: ['question'],
},
},
{
name: 'llm_web_search',
description: 'LLM-managed web search using Firecrawl for cross-platform support',
inputSchema: {
type: 'object',
properties: {
query: {
type: 'string',
description: 'The search query to execute',
},
maxResults: {
type: 'number',
description: 'Maximum results to return',
default: 5,
minimum: 1,
maximum: 20,
},
includeContent: {
type: 'boolean',
description: 'Include full content in results',
default: true,
},
llmInstructions: {
type: 'string',
description: 'LLM instructions for search optimization',
},
projectPath: {
type: 'string',
description: 'Path to project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
},
required: ['query'],
},
},
{
name: 'llm_cloud_management',
description: 'LLM-managed cloud provider operations with research-driven approach',
inputSchema: {
type: 'object',
properties: {
provider: {
type: 'string',
enum: ['aws', 'azure', 'gcp', 'redhat', 'ubuntu', 'macos'],
description: 'Cloud provider to use',
},
action: {
type: 'string',
description: 'Action to perform',
},
parameters: {
type: 'object',
description: 'Action parameters',
},
llmInstructions: {
type: 'string',
description: 'LLM instructions for command generation',
},
researchFirst: {
type: 'boolean',
description: 'Research best approach first',
default: true,
},
projectPath: {
type: 'string',
description: 'Path to project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
},
required: ['provider', 'action', 'llmInstructions'],
},
},
{
name: 'llm_database_management',
description: 'LLM-managed database operations with research-driven approach',
inputSchema: {
type: 'object',
properties: {
database: {
type: 'string',
enum: ['postgresql', 'mongodb', 'redis', 'mysql', 'mariadb'],
description: 'Database type to use',
},
action: {
type: 'string',
description: 'Database action to perform',
},
parameters: {
type: 'object',
description: 'Action parameters',
},
llmInstructions: {
type: 'string',
description: 'LLM instructions for command generation',
},
researchFirst: {
type: 'boolean',
description: 'Research best approach first',
default: true,
},
projectPath: {
type: 'string',
description: 'Path to project directory',
default: '.',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
},
required: ['database', 'action', 'llmInstructions'],
},
},
{
name: 'analyze_deployment_progress',
description: 'Analyze deployment progress and verify completion with outcome rules',
inputSchema: {
type: 'object',
properties: {
analysisType: {
type: 'string',
enum: ['tasks', 'cicd', 'progress', 'completion', 'comprehensive'],
description: 'Type of deployment analysis to perform',
default: 'comprehensive',
},
adrDirectory: {
type: 'string',
description: 'Directory containing ADR files',
default: 'docs/adrs',
},
todoPath: {
type: 'string',
description: 'Path to TODO.md file for task identification',
default: 'TODO.md',
},
cicdLogs: {
type: 'string',
description: 'CI/CD pipeline logs for analysis',
},
pipelineConfig: {
type: 'string',
description: 'CI/CD pipeline configuration',
},
deploymentTasks: {
type: 'array',
items: {
type: 'object',
properties: {
taskId: { type: 'string' },
taskName: { type: 'string' },
status: { type: 'string' },
progress: { type: 'number' },
category: { type: 'string' },
priority: { type: 'string' },
verificationCriteria: { type: 'array', items: { type: 'string' } },
expectedOutcome: { type: 'string' },
},
},
description: 'Deployment tasks for progress calculation',
},
outcomeRules: {
type: 'array',
items: {
type: 'object',
properties: {
ruleId: { type: 'string' },
description: { type: 'string' },
criteria: { type: 'array', items: { type: 'string' } },
verificationMethod: { type: 'string' },
},
},
description: 'Outcome rules for completion verification',
},
actualOutcomes: {
type: 'array',
items: {
type: 'object',
properties: {
taskId: { type: 'string' },
outcome: { type: 'string' },
evidence: { type: 'array', items: { type: 'string' } },
timestamp: { type: 'string' },
},
},
description: 'Actual deployment outcomes',
},
cicdStatus: {
type: 'object',
description: 'CI/CD pipeline status data',
},
environmentStatus: {
type: 'object',
description: 'Environment status data',
},
},
},
},
{
name: 'check_ai_execution_status',
description:
'Check AI execution configuration and status for debugging prompt-only mode issues',
inputSchema: {
type: 'object',
properties: {},
required: [],
},
},
{
name: 'get_workflow_guidance',
description:
'Get intelligent workflow guidance and tool recommendations based on your goals and project context to achieve expected outcomes efficiently',
inputSchema: {
type: 'object',
properties: {
goal: {
type: 'string',
description:
'What you want to accomplish (e.g., "analyze new project", "document existing decisions", "security audit", "modernize legacy system")',
},
projectContext: {
type: 'string',
description:
'Current state of your project (e.g., "new project", "existing project with ADRs", "legacy codebase", "greenfield development")',
enum: [
'new_project',
'existing_with_adrs',
'existing_without_adrs',
'legacy_codebase',
'greenfield',
'maintenance_mode',
'unknown',
],
},
availableAssets: {
type: 'array',
items: { type: 'string' },
description:
'What assets you already have (e.g., ["PRD.md", "existing ADRs", "codebase", "documentation", "test suite"])',
},
timeframe: {
type: 'string',
description: 'Available time/effort level',
enum: [
'quick_analysis',
'thorough_review',
'comprehensive_audit',
'ongoing_process',
],
},
primaryConcerns: {
type: 'array',
items: { type: 'string' },
description:
'Main areas of concern (e.g., ["security", "performance", "maintainability", "scalability", "compliance"])',
},
},
required: ['goal', 'projectContext'],
},
},
{
name: 'get_development_guidance',
description:
'Get comprehensive development guidance that translates architectural decisions and workflow recommendations into specific coding tasks, implementation patterns, and development roadmap',
inputSchema: {
type: 'object',
properties: {
developmentPhase: {
type: 'string',
description: 'Current development phase',
enum: [
'planning',
'setup',
'implementation',
'testing',
'deployment',
'maintenance',
'refactoring',
],
},
adrsToImplement: {
type: 'array',
items: { type: 'string' },
description:
'List of ADR titles or file paths that need to be implemented in code',
},
technologyStack: {
type: 'array',
items: { type: 'string' },
description:
'Current technology stack (e.g., ["TypeScript", "React", "Node.js", "PostgreSQL", "Docker"])',
},
currentProgress: {
type: 'string',
description: 'What has already been implemented or current state of development',
},
teamContext: {
type: 'object',
properties: {
size: {
type: 'string',
enum: ['solo', 'small_team', 'medium_team', 'large_team'],
},
experienceLevel: {
type: 'string',
enum: ['junior', 'mixed', 'senior', 'expert'],
},
},
},
timeline: {
type: 'string',
description: 'Development timeline or deadline constraints',
},
focusAreas: {
type: 'array',
items: { type: 'string' },
description:
'Specific areas to focus on (e.g., ["API design", "database schema", "testing strategy", "deployment pipeline"])',
},
},
required: ['developmentPhase'],
},
},
{
name: 'list_roots',
description:
'List available file system roots that can be accessed. Use this to discover what directories are available before reading files.',
inputSchema: {
type: 'object',
properties: {},
},
},
{
name: 'read_directory',
description:
'List files and folders in a directory. Use this to explore the file structure within accessible roots.',
inputSchema: {
type: 'object',
properties: {
path: {
type: 'string',
description:
'Directory path to list (relative to project root or absolute within roots)',
},
},
required: ['path'],
},
},
{
name: 'read_file',
description: 'Read contents of a file',
inputSchema: {
type: 'object',
properties: {
path: {
type: 'string',
description: 'Path to the file to read',
},
},
required: ['path'],
},
},
{
name: 'write_file',
description: 'Write content to a file',
inputSchema: {
type: 'object',
properties: {
path: {
type: 'string',
description: 'Path to the file to write',
},
content: {
type: 'string',
description: 'Content to write to the file',
},
},
required: ['path', 'content'],
},
},
{
name: 'list_directory',
description: 'List contents of a directory',
inputSchema: {
type: 'object',
properties: {
path: {
type: 'string',
description: 'Path to the directory to list',
},
},
required: ['path'],
},
},
{
name: 'generate_deployment_guidance',
description:
'Generate deployment guidance and instructions from ADRs with environment-specific configurations',
inputSchema: {
type: 'object',
properties: {
adrDirectory: {
type: 'string',
default: 'docs/adrs',
description: 'Directory containing ADR files',
},
environment: {
type: 'string',
enum: ['development', 'staging', 'production', 'all'],
default: 'production',
description: 'Target deployment environment',
},
format: {
type: 'string',
enum: ['markdown', 'scripts', 'structured', 'all'],
default: 'markdown',
description: 'Output format for guidance',
},
projectPath: {
type: 'string',
description:
'Project root path (optional, uses configured PROJECT_PATH if not provided)',
},
includeScripts: {
type: 'boolean',
default: true,
description: 'Generate deployment scripts',
},
includeConfigs: {
type: 'boolean',
default: true,
description: 'Generate configuration files',
},
includeValidation: {
type: 'boolean',
default: true,
description: 'Include validation and health checks',
},
technologyFilter: {
type: 'array',
items: {
type: 'string',
enum: [
'containerization',
'database',
'web-server',
'cache',
'message-queue',
'monitoring',
'security',
'ci-cd',
'infrastructure',
],
},
description: 'Filter by specific technology categories',
},
customRequirements: {
type: 'array',
items: { type: 'string' },
description: 'Additional custom requirements',
},
includeRollback: {
type: 'boolean',
default: true,
description: 'Include rollback procedures',
},
generateFiles: {
type: 'boolean',
default: false,
description: 'Actually generate files (vs just guidance)',
},
},
required: [],
},
},
{
name: 'smart_git_push',
description:
'AI-driven security-focused git push with credential detection, file filtering, and deployment metrics tracking. Tests should be run by calling AI and results provided.',
inputSchema: {
type: 'object',
properties: {
branch: {
type: 'string',
description:
'Target branch for push (optional, uses current branch if not specified)',
},
message: {
type: 'string',
description: 'Commit message (optional, commits staged files if provided)',
},
testResults: {
type: 'object',
description:
'Test results from AI-executed tests (required for proper deployment tracking)',
properties: {
success: {
type: 'boolean',
description: 'Whether all tests passed',
},
testsRun: {
type: 'number',
description: 'Total number of tests executed',
},
testsPassed: {
type: 'number',
description: 'Number of tests that passed',
},
testsFailed: {
type: 'number',
description: 'Number of tests that failed',
},
duration: {
type: 'number',
description: 'Test execution duration in seconds',
},
command: {
type: 'string',
description: 'Test command that was executed by AI',
},
output: {
type: 'string',
description: 'Test execution output',
},
failureDetails: {
type: 'array',
items: { type: 'string' },
description: 'Details of test failures',
},
testTypes: {
type: 'object',
description: 'Results broken down by test type (unit, integration, etc.)',
additionalProperties: {
type: 'object',
properties: {
passed: { type: 'number' },
failed: { type: 'number' },
},
},
},
},
required: ['success', 'testsRun', 'testsPassed', 'testsFailed'],
},
skipSecurity: {
type: 'boolean',
default: false,
description: 'Skip security scanning (NOT RECOMMENDED)',
},
dryRun: {
type: 'boolean',
default: false,
description: 'Show what would be pushed without actually pushing',
},
projectPath: {
type: 'string',
description: 'Path to project directory (defaults to current working directory)',
},
forceUnsafe: {
type: 'boolean',
default: false,
description: 'Override security blocks and test failures (DANGEROUS)',
},
},
},
},
{
name: 'deployment_readiness',
description:
'Comprehensive deployment readiness validation with test failure tracking, deployment history analysis, and hard blocking for unsafe deployments. Integrates with smart_git_push for deployment gating.',
inputSchema: {
type: 'object',
properties: {
operation: {
type: 'string',
enum: [
'check_readiness',
'validate_production',
'test_validation',
'deployment_history',
'full_audit',
'emergency_override',
],
description: 'Type of deployment readiness check to perform',
},
projectPath: {
type: 'string',
description: 'Path to project directory (defaults to current working directory)',
},
targetEnvironment: {
type: 'string',
enum: ['staging', 'production', 'integration'],
default: 'production',
description: 'Target deployment environment',
},
strictMode: {
type: 'boolean',
default: true,
description: 'Enable strict validation (recommended for production)',
},
allowMockCode: {
type: 'boolean',
default: false,
description: 'Allow mock code in deployment (NOT RECOMMENDED)',
},
productionCodeThreshold: {
type: 'number',
default: 85,
description: 'Minimum production code quality score (0-100)',
},
mockCodeMaxAllowed: {
type: 'number',
default: 0,
description: 'Maximum mock code indicators allowed',
},
maxTestFailures: {
type: 'number',
default: 0,
description: 'Maximum test failures allowed (0 = zero tolerance)',
},
requireTestCoverage: {
type: 'number',
default: 80,
description: 'Minimum test coverage percentage required',
},
blockOnFailingTests: {
type: 'boolean',
default: true,
description: 'Block deployment if tests are failing',
},
testSuiteRequired: {
type: 'array',
items: { type: 'string' },
default: [],
description: 'Required test suites that must pass',
},
maxRecentFailures: {
type: 'number',
default: 2,
description: 'Maximum recent deployment failures allowed',
},
deploymentSuccessThreshold: {
type: 'number',
default: 80,
description: 'Minimum deployment success rate required (%)',
},
blockOnRecentFailures: {
type: 'boolean',
default: true,
description: 'Block if recent deployments failed',
},
rollbackFrequencyThreshold: {
type: 'number',
default: 20,
description: 'Maximum rollback frequency allowed (%)',
},
requireAdrCompliance: {
type: 'boolean',
default: true,
description: 'Require ADR compliance validation',
},
integrateTodoTasks: {
type: 'boolean',
default: true,
description: 'Auto-create blocking tasks for issues',
},
updateHealthScoring: {
type: 'boolean',
default: true,
description: 'Update project health scores',
},
triggerSmartGitPush: {
type: 'boolean',
default: false,
description: 'Trigger smart git push validation',
},
emergencyBypass: {
type: 'boolean',
default: false,
description: 'Emergency bypass for critical fixes',
},
businessJustification: {
type: 'string',
description:
'Business justification for overrides (required for emergency_override)',
},
approvalRequired: {
type: 'boolean',
default: true,
description: 'Require approval for overrides',
},
enableMemoryIntegration: {
type: 'boolean',
description:
'Enable memory entity storage for deployment assessment tracking and historical analysis',
default: true,
},
migrateExistingHistory: {
type: 'boolean',
description: 'Migrate existing JSON-based deployment history to memory entities',
default: true,
},
},
required: ['operation'],
},
},
{
name: 'troubleshoot_guided_workflow',
description:
'Structured failure analysis and test plan generation with memory integration for troubleshooting session tracking and intelligent ADR/research suggestion capabilities - provide JSON failure info to get specific test commands',
inputSchema: {
type: 'object',
properties: {
operation: {
type: 'string',
enum: ['analyze_failure', 'generate_test_plan', 'full_workflow'],
description: 'Type of troubleshooting operation',
},
failure: {
type: 'object',
properties: {
failureType: {
type: 'string',
enum: [
'test_failure',
'deployment_failure',
'build_failure',
'runtime_error',
'performance_issue',
'security_issue',
'other',
],
description: 'Type of failure',
},
failureDetails: {
type: 'object',
properties: {
command: {
type: 'string',
description: 'Command that failed (optional)',
},
exitCode: {
type: 'number',
description: 'Exit code of failed process (optional)',
},
errorMessage: {
type: 'string',
description: 'Primary error message',
},
stackTrace: {
type: 'string',
description: 'Stack trace if available (optional)',
},
logOutput: {
type: 'string',
description: 'Relevant log output (optional)',
},
environment: {
type: 'string',
description: 'Environment where failure occurred (optional)',
},
timestamp: {
type: 'string',
description: 'When the failure occurred (optional)',
},
affectedFiles: {
type: 'array',
items: { type: 'string' },
description: 'Files involved in the failure (optional)',
},
},
required: ['errorMessage'],
description: 'Detailed failure information',
},
context: {
type: 'object',
properties: {
recentChanges: {
type: 'string',
description: 'Recent changes that might be related (optional)',
},
reproducible: {
type: 'boolean',
description: 'Whether the failure is reproducible (optional)',
},
frequency: {
type: 'string',
description: 'How often this failure occurs (optional)',
},
impact: {
type: 'string',
enum: ['low', 'medium', 'high', 'critical'],
description: 'Impact level of the failure (optional)',
},
},
description: 'Additional context about the failure (optional)',
},
},
required: ['failureType', 'failureDetails'],
description:
'Structured failure information (required for analyze_failure and generate_test_plan)',
},
projectPath: {
type: 'string',
description: 'Path to project directory (optional)',
},
adrDirectory: {
type: 'string',
description: 'ADR directory path',
default: 'docs/adrs',
},
todoPath: {
type: 'string',
description: 'Path to TODO.md file',
default: 'TODO.md',
},
enableMemoryIntegration: {
type: 'boolean',
description:
'Enable memory entity storage for troubleshooting session tracking and pattern recognition',
default: true,
},
enablePatternRecognition: {
type: 'boolean',
description: 'Enable automatic pattern recognition and failure classification',
default: true,
},
enableAdrSuggestion: {
type: 'boolean',
description: 'Enable automatic ADR suggestion based on recurring failures',
default: true,
},
enableResearchGeneration: {
type: 'boolean',
description:
'Enable automatic research question generation for persistent problems',
default: true,
},
conversationContext: CONVERSATION_CONTEXT_SCHEMA,
},
required: ['operation'],
},
},
{
name: 'smart_score',
description:
'Central coordination for project health scoring system - recalculate, sync, diagnose, optimize, and reset scores across all MCP tools',
inputSchema: {
type: 'object',
properties: {
operation: {
type: 'string',
enum: [
'recalculate_scores',
'sync_scores',
'diagnose_scores',
'optimize_weights',
'reset_scores',
'get_score_trends',
'get_intent_scores',
],
description: 'Smart scoring operation to perform',
},
projectPath: {
type: 'string',
description: 'Path to project directory',
},
components: {
type: 'array',
items: {
type: 'string',
enum: [
'task_completion',
'deployment_readiness',
'architecture_compliance',
'security_posture',
'code_quality',
'all',
],
},
default: ['all'],
description: 'Score components to recalculate (for recalculate_scores operation)',
},
forceUpdate: {
type: 'boolean',
default: false,
description: 'Force update even if data is fresh',
},
updateSources: {
type: 'boolean',
default: true,
description: 'Trigger source tool updates before recalculating',
},
todoPath: {
type: 'string',
default: 'TODO.md',
description: 'Path to TODO.md file (for sync_scores operation)',
},
triggerTools: {
type: 'array',
items: {
type: 'string',
enum: [
'smart_git_push',
'compare_adr_progress',
'analyze_content_security',
'validate_rules',
],
},
description: 'Tools to trigger for fresh data (for sync_scores operation)',
},
rebalanceWeights: {
type: 'boolean',
default: false,
description: 'Recalculate optimal scoring weights (for sync_scores operation)',
},
includeHistory: {
type: 'boolean',
default: true,
description: 'Include score history analysis (for diagnose_scores operation)',
},
checkDataFreshness: {
type: 'boolean',
default: true,
description:
'Validate data freshness across tools (for diagnose_scores operation)',
},
suggestImprovements: {
type: 'boolean',
default: true,
description:
'Provide score improvement suggestions (for diagnose_scores operation)',
},
analysisMode: {
type: 'string',
enum: ['current_state', 'historical_data', 'project_type'],
default: 'current_state',
description: 'Method for weight optimization (for optimize_weights operation)',
},
customWeights: {
type: 'object',
properties: {
taskCompletion: { type: 'number', minimum: 0, maximum: 1 },
deploymentReadiness: { type: 'number', minimum: 0, maximum: 1 },
architectureCompliance: { type: 'number', minimum: 0, maximum: 1 },
securityPosture: { type: 'number', minimum: 0, maximum: 1 },
codeQuality: { type: 'number', minimum: 0, maximum: 1 },
},
description: 'Custom weight overrides (for optimize_weights operation)',
},
previewOnly: {
type: 'boolean',
default: false,
description: 'Preview changes without applying (for optimize_weights operation)',
},
component: {
type: 'string',
enum: [
'task_completion',
'deployment_readiness',
'architecture_compliance',
'security_posture',
'code_quality',
'all',
],
default: 'all',
description: 'Score component to reset (for reset_scores operation)',
},
preserveHistory: {
type: 'boolean',
default: true,
description: 'Preserve score history in backup (for reset_scores operation)',
},
recalculateAfterReset: {
type: 'boolean',
default: true,
description: 'Immediately recalculate after reset (for reset_scores operation)',
},
intentId: {
type: 'string',
description:
'Intent ID to get score trends for (for get_intent_scores operation)',
},
},
required: ['operation', 'projectPath'],
},
},
{
name: 'mcp_planning',
description:
'Enhanced project planning and workflow management tool - phase-based project management, team resource allocation, progress tracking, risk analysis, and executive reporting',
inputSchema: {
type: 'object',
properties: {
operation: {
type: 'string',
enum: [
'create_project',
'manage_phases',
'track_progress',
'manage_resources',
'risk_analysis',
'generate_reports',
],
description: 'Project planning operation to perform',
},
projectPath: {
type: 'string',
description: 'Project root path',
},
projectName: {
type: 'string',
description: 'Project name (for create_project operation)',
},
description: {
type: 'string',
description: 'Project description (for create_project operation)',
},
phases: {
type: 'array',
items: {
type: 'object',
properties: {
name: { type: 'string' },
duration: { type: 'string' },
dependencies: {
type: 'array',
items: { type: 'string' },
default: [],
},
milestones: {
type: 'array',
items: { type: 'string' },
default: [],
},
},
required: ['name', 'duration'],
},
description: 'Initial project phases (for create_project operation)',
},
team: {
type: 'array',
items: {
type: 'object',
properties: {
name: { type: 'string' },
role: { type: 'string' },
skills: {
type: 'array',
items: { type: 'string' },
default: [],
},
capacity: { type: 'string' },
},
required: ['name', 'role', 'capacity'],
},
default: [],
description: 'Team structure (for create_project operation)',
},
importFromAdrs: {
type: 'boolean',
default: true,
description: 'Import phases from existing ADRs (for create_project operation)',
},
importFromTodos: {
type: 'boolean',
default: true,
description: 'Import tasks from TODO system (for create_project operation)',
},
action: {
type: 'string',
enum: [
'list',
'create',
'update',
'delete',
'transition',
'add',
'remove',
'allocate',
'optimize',
],
description: 'Management action (for manage_phases/manage_resources operations)',
},
phaseId: {
type: 'string',
description: 'Phase ID for phase operations',
},
phaseData: {
type: 'object',
properties: {
name: { type: 'string' },
description: { type: 'string' },
estimatedDuration: { type: 'string' },
dependencies: {
type: 'array',
items: { type: 'string' },
},
milestones: {
type: 'array',
items: { type: 'string' },
},
linkedAdrs: {
type: 'array',
items: { type: 'string' },
},
},
description: 'Phase data for create/update operations',
},
targetStatus: {
type: 'string',
enum: ['planning', 'active', 'completed', 'blocked', 'cancelled'],
description: 'Target status for phase transition',
},
reportType: {
type: 'string',
enum: [
'summary',
'detailed',
'gantt',
'milestones',
'risks',
'executive',
'status',
'health',
'team_performance',
'milestone_tracking',
],
default: 'summary',
description: 'Type of progress report or generated report',
},
timeframe: {
type: 'string',
enum: [
'current',
'weekly',
'monthly',
'quarterly',
'week',
'month',
'quarter',
'project',
],
default: 'current',
description: 'Time frame for reports and tracking',
},
includeVisuals: {
type: 'boolean',
default: true,
description: 'Include visual progress indicators',
},
updateTaskProgress: {
type: 'boolean',
default: true,
description: 'Sync progress from TODO system',
},
memberId: {
type: 'string',
description: 'Team member ID for resource operations',
},
memberData: {
type: 'object',
properties: {
name: { type: 'string' },
role: { type: 'string' },
skills: {
type: 'array',
items: { type: 'string' },
},
capacity: { type: 'string' },
},
description: 'Team member data for resource operations',
},
allocationData: {
type: 'object',
properties: {
phaseId: { type: 'string' },
allocation: {
type: 'number',
minimum: 0,
maximum: 100,
},
},
required: ['phaseId', 'allocation'],
description: 'Resource allocation data',
},
analysisType: {
type: 'string',
enum: ['automated', 'manual', 'comprehensive'],
default: 'comprehensive',
description: 'Type of risk analysis',
},
includeAdrRisks: {
type: 'boolean',
default: true,
description: 'Analyze risks from ADR complexity',
},
includeDependencyRisks: {
type: 'boolean',
default: true,
description: 'Analyze dependency chain risks',
},
includeResourceRisks: {
type: 'boolean',
default: true,
description: 'Analyze resource allocation risks',
},
generateMitigation: {
type: 'boolean',
default: true,
description: 'Generate mitigation strategies',
},
format: {
type: 'string',
enum: ['markdown', 'json', 'html'],
default: 'markdown',
description: 'Report output format',
},
includeCharts: {
type: 'boolean',
default: true,
description: 'Include progress charts and graphs',
},
},
required: ['operation', 'projectPath'],
},
},
{
name: 'interactive_adr_planning',
description:
'Interactive guided ADR planning and creation tool - walks users through structured decision-making process with research integration, option evaluation, and automatic ADR generation. TIP: Start by reading @.mcp-server-context.md to understand project context and previous decisions.',
inputSchema: {
type: 'object',
properties: {
operation: {
type: 'string',
enum: [
'start_session',
'continue_session',
'provide_input',
'request_research',
'evaluate_options',
'make_decision',
'assess_impact',
'plan_implementation',
'generate_adr',
'update_todos',
'get_guidance',
'save_session',
'complete_session',
],
description: 'Interactive planning operation to perform',
},
sessionId: {
type: 'string',
description:
'Planning session ID (required for all operations except start_session)',
},
input: {
type: 'string',
description: 'User input for the current phase (varies by phase)',
},
projectPath: {
type: 'string',
description: 'Project root path',
},
autoResearch: {
type: 'boolean',
default: true,
description: 'Automatically trigger research when needed',
},
generateTodos: {
type: 'boolean',
default: true,
description: 'Automatically generate TODO items from decisions',
},
},
required: ['operation', 'projectPath'],
},
},
{
name: 'memory_loading',
description:
'Advanced memory loading tool for the memory-centric architecture. Query, explore, and manage memory entities and relationships. Load ADRs into memory system and perform intelligent queries.',
inputSchema: {
type: 'object',
properties: {
action: {
type: 'string',
enum: [
'load_adrs',
'query_entities',
'get_entity',
'find_related',
'get_intelligence',
'create_snapshot',
],
description: 'Memory operation to perform',
default: 'query_entities',
},
query: {
type: 'object',
properties: {
entityTypes: {
type: 'array',
items: {
type: 'string',
enum: [
'architectural_decision',
'code_component',
'business_requirement',
'technical_constraint',
'quality_concern',
'implementation_pattern',
'environmental_factor',
'stakeholder_input',
'knowledge_artifact',
'decision_context',
],
},
description: 'Filter by entity types',
},
tags: {
type: 'array',
items: { type: 'string' },
description: 'Filter by tags',
},
textQuery: {
type: 'string',
description: 'Full-text search query',
},
relationshipTypes: {
type: 'array',
items: {
type: 'string',
enum: [
'depends_on',
'influences',
'conflicts_with',
'implements',
'supersedes',
'relates_to',
'originated_from',
'impacts',
'constrains',
],
},
description: 'Filter by relationship types',
},
confidenceThreshold: {
type: 'number',
minimum: 0,
maximum: 1,
description: 'Minimum confidence threshold',
},
relevanceThreshold: {
type: 'number',
minimum: 0,
maximum: 1,
description: 'Minimum relevance threshold',
},
timeRange: {
type: 'object',
properties: {
from: { type: 'string', description: 'Start date (ISO 8601)' },
to: { type: 'string', description: 'End date (ISO 8601)' },
},
description: 'Filter by time range',
},
contextFilters: {
type: 'object',
properties: {
projectPhase: { type: 'string', description: 'Project phase filter' },
businessDomain: { type: 'string', description: 'Business domain filter' },
technicalStack: {
type: 'array',
items: { type: 'string' },
description: 'Technical stack filter',
},
environmentalFactors: {
type: 'array',
items: { type: 'string' },
description: 'Environmental factors filter',
},
},
description: 'Context-based filters',
},
limit: {
type: 'number',
minimum: 1,
description: 'Maximum number of results',
},
sortBy: {
type: 'string',
enum: ['relevance', 'confidence', 'lastModified', 'created', 'accessCount'],
description: 'Sort field',
default: 'relevance',
},
includeRelated: {
type: 'boolean',
description: 'Include related entities and relationships',
default: false,
},
relationshipDepth: {
type: 'number',
minimum: 1,
maximum: 5,
description: 'Maximum relationship traversal depth',
default: 2,
},
},
description: 'Query parameters for entity search',
},
entityId: {
type: 'string',
description: 'Entity ID for get_entity and find_related actions',
},
maxDepth: {
type: 'number',
minimum: 1,
maximum: 5,
description: 'Maximum depth for relationship traversal (find_related action)',
default: 2,
},
forceReload: {
type: 'boolean',
description: 'Force reload of ADRs (load_adrs action)',
default: false,
},
},
},
},
{
name: 'expand_analysis_section',
description:
'Retrieve full analysis content from tiered responses. Expand entire analysis or specific sections stored in memory. Use this when a tool returns a summary with an expandable ID.',
inputSchema: {
type: 'object',
properties: {
expandableId: {
type: 'string',
description: 'ID of the expandable analysis (provided in tiered response)',
},
section: {
type: 'string',
description:
'Optional: Specific section to expand (omit to get full analysis). Available sections are listed in the tiered response.',
},
format: {
type: 'string',
enum: ['markdown', 'json'],
description: 'Output format (default: markdown)',
default: 'markdown',
},
},
required: ['expandableId'],
},
},
{
name: 'tool_chain_orchestrator',
description:
'AI-powered dynamic tool sequencing - intelligently analyze user requests and generate structured tool execution plans',
inputSchema: {
type: 'object',
properties: {
userRequest: {
type: 'string',
description: 'User request to analyze and create tool execution plan for',
},
availableTools: {
type: 'array',
items: { type: 'string' },
description: 'List of available MCP tools to orchestrate',
},
executionMode: {
type: 'string',
enum: ['plan_only', 'plan_and_execute', 'validate_plan'],
description: 'Orchestration mode',
default: 'plan_only',
},
maxSteps: {
type: 'number',
description: 'Maximum number of steps in the execution plan',
default: 10,
},
allowParallel: {
type: 'boolean',
description: 'Allow parallel execution of independent steps',
default: true,
},
contextHints: {
type: 'array',
items: { type: 'string' },
description: 'Additional context hints for better plan generation',
},
},
required: ['userRequest'],
},
},
{
name: 'expand_memory',
description:
'Phase 3: Retrieve and expand stored content from a tiered response using its expandable ID',
inputSchema: {
type: 'object',
properties: {
expandableId: {
type: 'string',
description: 'Expandable ID from a tiered response',
},
section: {
type: 'string',
description: 'Optional: specific section to expand',
},
includeContext: {
type: 'boolean',
description: 'Include related conversation context and knowledge graph state',
default: true,
},
},
required: ['expandableId'],
},
},
{
name: 'query_conversation_history',
description: 'Phase 3: Search and retrieve conversation sessions based on filters',
inputSchema: {
type: 'object',
properties: {
projectPath: {
type: 'string',
description: 'Filter by project path',
},
dateRange: {
type: 'object',
properties: {
start: { type: 'string', description: 'Start date (ISO 8601)' },
end: { type: 'string', description: 'End date (ISO 8601)' },
},
description: 'Filter by date range',
},
toolsUsed: {
type: 'array',
items: { type: 'string' },
description: 'Filter by tools used in the session',
},
keyword: {
type: 'string',
description: 'Search keyword in conversation turns',
},
limit: {
type: 'number',
description: 'Maximum number of sessions to return',
default: 10,
},
},
},
},
{
name: 'get_conversation_snapshot',
description:
'Phase 3: Get current conversation context snapshot for resumption or analysis',
inputSchema: {
type: 'object',
properties: {
recentTurnCount: {
type: 'number',
description: 'Number of recent turns to include',
default: 5,
},
},
},
},
{
name: 'get_memory_stats',
description: 'Phase 3: Get statistics about stored conversation memory',
inputSchema: {
type: 'object',
properties: {},
},
},
{
name: 'get_server_context',
description:
"Generate a comprehensive context file showing the server's current state, memory, and capabilities. Creates .mcp-server-context.md that can be @ referenced in conversations for instant LLM awareness",
inputSchema: {
type: 'object',
properties: {
writeToFile: {
type: 'boolean',
description: 'Whether to write the context to .mcp-server-context.md file',
default: true,
},
outputPath: {
type: 'string',
description: 'Custom output path for the context file',
},
includeDetailed: {
type: 'boolean',
description: 'Include detailed information',
default: true,
},
maxRecentItems: {
type: 'number',
description: 'Maximum number of recent items to show',
default: 5,
},
},
},
},
],
};
});
/**
* Call Tool Handler - MCP Protocol Endpoint
*
* @description Executes specific tools with provided arguments. This is the core
* execution endpoint that routes tool calls to their respective implementations.
* Includes comprehensive error handling, argument validation, and response masking.
*
* @param {CallToolRequest} request - MCP tool execution request
* @param {string} request.params.name - Tool name to execute
* @param {Object} request.params.arguments - Tool-specific arguments
*
* @returns {Promise<CallToolResult>} Tool execution result with content and metadata
*
* @throws {McpAdrError} When tool execution fails or arguments are invalid
*
* @example
* ```typescript
* // Execute research tool
* const result = await mcpClient.callTool('perform_research', {
* question: 'What authentication methods are used?',
* projectPath: '/path/to/project'
* });
*
* console.log(result.content); // Research findings
* ```
*
* @example
* ```typescript
* // Execute ADR validation
* const validation = await mcpClient.callTool('validate_adr', {
* adrPath: 'docs/adrs/0001-auth-choice.md',
* includeEnvironmentCheck: true
* });
*
* console.log(validation.isValid); // true/false
* console.log(validation.findings); // Validation issues
* ```
*
* @mcp-endpoint
* @category Tools
* @category Execution
*/
this.server.setRequestHandler(CallToolRequestSchema, async request => {
const { name, arguments: args } = request.params;
// Create context for progress notifications and logging
const context: ToolContext = {
info: (message: string) => {
this.logger.info(message);
// Note: MCP progress notifications will be available in future SDK versions
// For now, we log to server console for visibility
},
report_progress: (progress: number, total?: number) => {
const percentage = total ? Math.round((progress / total) * 100) : progress;
this.logger.info(`Progress: ${percentage}%${total ? ` (${progress}/${total})` : ''}`);
},
warn: (message: string) => {
this.logger.warn(message);
},
error: (message: string) => {
this.logger.error(message);
},
};
try {
let response: CallToolResult;
const safeArgs = args || {};
switch (name) {
case 'analyze_project_ecosystem':
response = await this.analyzeProjectEcosystem(
safeArgs as unknown as AnalyzeProjectEcosystemArgs,
context
);
break;
case 'get_architectural_context':
response = await this.getArchitecturalContext(
safeArgs as unknown as GetArchitecturalContextArgs
);
break;
case 'generate_adrs_from_prd':
response = await this.generateAdrsFromPrd(safeArgs, context);
break;
case 'compare_adr_progress':
response = await this.compareAdrProgress(safeArgs);
break;
case 'analyze_content_security':
response = await this.analyzeContentSecurity(
safeArgs as unknown as AnalyzeContentSecurityArgs
);
break;
case 'generate_content_masking':
response = await this.generateContentMasking(
safeArgs as unknown as GenerateContentMaskingArgs
);
break;
case 'configure_custom_patterns':
response = await this.configureCustomPatterns(
safeArgs as unknown as ConfigureCustomPatternsArgs
);
break;
case 'apply_basic_content_masking':
response = await this.applyBasicContentMasking(
safeArgs as unknown as ApplyBasicContentMaskingArgs
);
break;
case 'validate_content_masking':
response = await this.validateContentMasking(
safeArgs as unknown as ValidateContentMaskingArgs
);
break;
case 'manage_cache':
response = await this.manageCache(safeArgs);
break;
case 'configure_output_masking':
response = await this.configureOutputMasking(safeArgs);
break;
case 'suggest_adrs':
response = await this.suggestAdrs(safeArgs);
break;
case 'generate_adr_from_decision':
response = await this.generateAdrFromDecision(
safeArgs as unknown as GenerateAdrFromDecisionArgs
);
break;
case 'generate_adr_bootstrap':
response = await this.generateAdrBootstrap(safeArgs);
break;
case 'bootstrap_validation_loop':
response = await this.bootstrapValidationLoop(safeArgs);
break;
case 'discover_existing_adrs':
response = await this.discoverExistingAdrs(safeArgs, context);
break;
case 'review_existing_adrs':
response = await this.reviewExistingAdrs(safeArgs);
break;
case 'validate_adr':
response = await this.validateAdr(safeArgs);
break;
case 'validate_all_adrs':
response = await this.validateAllAdrs(safeArgs);
break;
case 'incorporate_research':
response = await this.incorporateResearch(safeArgs);
break;
case 'create_research_template':
response = await this.createResearchTemplate(safeArgs);
break;
case 'request_action_confirmation':
response = await this.requestActionConfirmation(safeArgs);
break;
case 'generate_rules':
response = await this.generateRules(safeArgs);
break;
case 'validate_rules':
response = await this.validateRules(safeArgs as unknown as ValidateRulesArgs);
break;
case 'create_rule_set':
response = await this.createRuleSet(safeArgs as unknown as CreateRuleSetArgs);
break;
case 'analyze_environment':
response = await this.analyzeEnvironment(safeArgs);
break;
case 'generate_research_questions':
response = await this.generateResearchQuestions(safeArgs);
break;
case 'perform_research':
response = await this.performResearch(safeArgs, context);
break;
case 'llm_web_search':
response = await this.llmWebSearch(safeArgs);
break;
case 'llm_cloud_management':
response = await this.llmCloudManagement(safeArgs);
break;
case 'llm_database_management':
response = await this.llmDatabaseManagement(safeArgs);
break;
case 'analyze_deployment_progress':
response = await this.analyzeDeploymentProgress(safeArgs);
break;
case 'check_ai_execution_status':
response = await this.checkAIExecutionStatus(safeArgs);
break;
case 'get_workflow_guidance':
response = await this.getWorkflowGuidance(
safeArgs as unknown as GetWorkflowGuidanceArgs
);
break;
case 'get_development_guidance':
response = await this.getDevelopmentGuidance(
safeArgs as unknown as GetDevelopmentGuidanceArgs
);
break;
case 'list_roots':
response = await this.listRoots();
break;
case 'read_directory':
response = await this.readDirectory(safeArgs);
break;
case 'read_file':
response = await this.readFile(safeArgs as unknown as ReadFileArgs);
break;
case 'write_file':
response = await this.writeFile(safeArgs as unknown as WriteFileArgs);
break;
case 'list_directory':
response = await this.listDirectory(safeArgs);
break;
case 'generate_deployment_guidance':
response = await this.generateDeploymentGuidance(safeArgs);
break;
case 'smart_git_push':
response = await this.smartGitPush(safeArgs);
break;
case 'deployment_readiness':
response = await this.deploymentReadiness(safeArgs);
break;
case 'troubleshoot_guided_workflow':
response = await this.troubleshootGuidedWorkflow(safeArgs);
break;
case 'smart_score':
response = await this.smartScore(safeArgs);
break;
case 'mcp_planning':
response = await this.mcpPlanning(safeArgs);
break;
case 'memory_loading':
response = await this.memoryLoading(safeArgs);
break;
case 'expand_analysis_section':
response = await this.expandAnalysisSection(safeArgs);
break;
case 'interactive_adr_planning':
response = await this.interactiveAdrPlanning(safeArgs);
break;
case 'tool_chain_orchestrator':
response = await this.toolChainOrchestrator(
safeArgs as unknown as ToolChainOrchestratorArgs
);
break;
case 'expand_memory':
response = await this.expandMemory(safeArgs);
break;
case 'query_conversation_history':
response = await this.queryConversationHistory(safeArgs);
break;
case 'get_conversation_snapshot':
response = await this.getConversationSnapshot(safeArgs);
break;
case 'get_memory_stats':
response = await this.getMemoryStats();
break;
case 'get_server_context':
response = await this.getServerContext(safeArgs);
break;
default:
throw new McpAdrError(`Unknown tool: ${name}`, 'UNKNOWN_TOOL');
}
// Track tool execution in knowledge graph
await this.trackToolExecution(name, args, response, true);
// Apply state reinforcement (Phase 2: Context Decay Mitigation) and content masking
// Also record conversation turn (Phase 3: Structured External Memory)
return await this.enrichResponseWithStateReinforcement(response, name, args);
} catch (error) {
// Track failed execution
await this.trackToolExecution(
name,
args,
{},
false,
error instanceof Error ? error.message : String(error)
);
if (error instanceof McpAdrError) {
throw error;
}
throw new McpAdrError(
`Tool execution failed: ${error instanceof Error ? error.message : String(error)}`,
'TOOL_EXECUTION_ERROR'
);
}
});
/**
* List Resources Handler - MCP Protocol Endpoint
*
* @description Returns available resources for client access including the
* architectural knowledge graph and project analysis data. Resources provide
* read-only access to server-managed data structures.
*
* @returns {Promise<{resources: Array}>} Available resources with URIs and descriptions
*
* @example
* ```typescript
* // List available resources
* const resources = await mcpClient.listResources();
* console.log(resources.resources.length); // Available resources
*
* // Find knowledge graph resource
* const kgResource = resources.resources.find(r =>
* r.uri === 'adr://architectural_knowledge_graph'
* );
* console.log(kgResource.name); // "Architectural Knowledge Graph"
* ```
*
* @mcp-endpoint
* @category Resources
*/
this.server.setRequestHandler(ListResourcesRequestSchema, async () => {
return {
resources: [
// Existing resources (refactored to return data)
{
uri: 'adr://architectural_knowledge_graph',
name: 'Architectural Knowledge Graph',
description:
'Complete architectural knowledge graph with technologies, patterns, and relationships',
mimeType: 'application/json',
},
{
uri: 'adr://analysis_report',
name: 'Analysis Report',
description: 'Comprehensive project analysis report with metrics and recommendations',
mimeType: 'application/json',
},
{
uri: 'adr://adr_list',
name: 'ADR List',
description: 'List of all Architectural Decision Records with status and metadata',
mimeType: 'application/json',
},
// NEW Phase 1 Resources
{
uri: 'adr://todo_list',
name: 'Todo List',
description: 'Current project task list with status, priorities, and dependencies',
mimeType: 'application/json',
},
{
uri: 'adr://research_index',
name: 'Research Index',
description: 'Index of all research documents and findings with metadata',
mimeType: 'application/json',
},
{
uri: 'adr://rule_catalog',
name: 'Rule Catalog',
description: 'Catalog of all architectural and validation rules from ADRs and code',
mimeType: 'application/json',
},
{
uri: 'adr://rule_generation',
name: 'Rule Generation',
description:
'AI-powered rule generation from ADRs and code patterns. Supports query parameters: ?operation=generate|validate|create_set, ?source=adrs|patterns|both, ?knowledge=true|false, ?enhanced=true|false, ?format=json|yaml|both, ?comprehensive=true|false',
mimeType: 'application/json',
},
{
uri: 'adr://project_status',
name: 'Project Status',
description: 'Current project status and health metrics aggregated from all sources',
mimeType: 'application/json',
},
// NEW Phase 2 Templated Resources
{
uri: 'adr://adr/{id}',
name: 'ADR by ID',
description: 'Individual Architectural Decision Record by ID or title match',
mimeType: 'application/json',
},
{
uri: 'adr://research/{topic}',
name: 'Research by Topic',
description: 'Research documents filtered by topic with full content',
mimeType: 'application/json',
},
{
uri: 'adr://todo/{task_id}',
name: 'Todo by Task ID',
description:
'Individual task details by ID or title match with dependencies and history',
mimeType: 'application/json',
},
{
uri: 'adr://rule/{rule_id}',
name: 'Rule by ID',
description:
'Individual architectural rule by ID or name match with violations and usage stats',
mimeType: 'application/json',
},
// NEW Phase 3 Advanced Resources
{
uri: 'adr://deployment_status',
name: 'Deployment Status',
description:
'Current deployment state with health checks, build status, and readiness score',
mimeType: 'application/json',
},
{
uri: 'adr://environment_analysis',
name: 'Environment Analysis',
description:
'System environment details including platform, dependencies, and capabilities',
mimeType: 'application/json',
},
{
uri: 'adr://memory_snapshots',
name: 'Memory Snapshots',
description:
'Knowledge graph snapshots with statistics, insights, and relationship data',
mimeType: 'application/json',
},
{
uri: 'adr://project_metrics',
name: 'Project Metrics',
description:
'Code metrics and quality scores including codebase stats, quality assessment, and git metrics',
mimeType: 'application/json',
},
{
uri: 'adr://technology/{name}',
name: 'Technology by Name',
description:
'Individual technology analysis by name with usage, relationships, and adoption status',
mimeType: 'application/json',
},
{
uri: 'adr://pattern/{name}',
name: 'Pattern by Name',
description:
'Individual pattern analysis by name with quality metrics, relationships, and examples',
mimeType: 'application/json',
},
// NEW Phase 4 Final Resources
{
uri: 'adr://deployment_history',
name: 'Deployment History',
description:
'Historical deployment data with trends, failure analysis, and patterns. Supports query parameters: ?period=7d|30d|90d|1y|all, ?environment=production|staging|development|all, ?includeFailures=true|false, ?includeMetrics=true|false, ?format=summary|detailed',
mimeType: 'application/json',
},
{
uri: 'adr://code_quality',
name: 'Code Quality',
description:
'Comprehensive code quality assessment with metrics, issues, and recommendations. Supports query parameters: ?scope=full|changes|critical, ?includeMetrics=true|false, ?includeRecommendations=true|false, ?threshold=0-100, ?format=summary|detailed',
mimeType: 'application/json',
},
],
};
});
/**
* Read Resource Handler - MCP Protocol Endpoint
*
* @description Reads specific resource content by URI. Provides access to
* architectural knowledge graphs, project analysis data, and other server-managed
* resources with appropriate content masking applied.
*
* @param {ReadResourceRequest} request - MCP resource read request
* @param {string} request.params.uri - Resource URI to read
*
* @returns {Promise<ReadResourceResult>} Resource content with metadata
*
* @throws {McpAdrError} When resource URI is invalid or access fails
*
* @example
* ```typescript
* // Read knowledge graph resource
* const kgData = await mcpClient.readResource(
* 'adr://architectural_knowledge_graph'
* );
* console.log(kgData.contents); // Knowledge graph JSON
* ```
*
* @mcp-endpoint
* @category Resources
*/
this.server.setRequestHandler(ReadResourceRequestSchema, async request => {
const { uri } = request.params;
try {
const response = await this.readResource(uri);
return await this.applyOutputMasking(response);
} catch (error) {
if (error instanceof McpAdrError) {
throw error;
}
throw new McpAdrError(
`Resource reading failed: ${error instanceof Error ? error.message : String(error)}`,
'RESOURCE_ERROR'
);
}
});
/**
* List Prompts Handler - MCP Protocol Endpoint
*
* @description Returns available prompt templates for ADR analysis, research,
* and architectural decision support. Prompts can be executed directly or
* used as templates for custom implementations.
*
* @returns {Promise<{prompts: Array}>} Available prompt templates with metadata
*
* @example
* ```typescript
* // List available prompts
* const prompts = await mcpClient.listPrompts();
* console.log(prompts.prompts.length); // Available prompt templates
*
* // Find ADR analysis prompt
* const adrPrompt = prompts.prompts.find(p =>
* p.name === 'adr_analysis_prompt'
* );
* console.log(adrPrompt.description); // Prompt description
* ```
*
* @mcp-endpoint
* @category Prompts
*/
this.server.setRequestHandler(ListPromptsRequestSchema, async () => {
const { allPrompts } = await import('./prompts/index.js');
return {
prompts: allPrompts.map(prompt => ({
name: prompt.name,
description: prompt.description,
arguments: prompt.arguments,
})),
};
});
/**
* Get Prompt Handler - MCP Protocol Endpoint
*
* @description Executes specific prompt templates with provided arguments.
* Returns formatted prompts ready for AI execution or further processing.
* Supports dynamic argument injection and template customization.
*
* @param {GetPromptRequest} request - MCP prompt execution request
* @param {string} request.params.name - Prompt template name
* @param {Object} request.params.arguments - Template-specific arguments
*
* @returns {Promise<GetPromptResult>} Formatted prompt with metadata
*
* @throws {McpAdrError} When prompt template is not found or arguments are invalid
*
* @example
* ```typescript
* // Execute ADR analysis prompt
* const prompt = await mcpClient.getPrompt('adr_analysis_prompt', {
* adrPath: 'docs/adrs/0001-auth.md',
* projectContext: 'microservices architecture'
* });
*
* console.log(prompt.messages); // Formatted prompt messages
* ```
*
* @example
* ```typescript
* // Execute research prompt
* const researchPrompt = await mcpClient.getPrompt('research_question_prompt', {
* domain: 'authentication',
* complexity: 'advanced'
* });
*
* console.log(researchPrompt.messages[0].content); // Research prompt
* ```
*
* @mcp-endpoint
* @category Prompts
* @category Execution
*/
this.server.setRequestHandler(GetPromptRequestSchema, async request => {
const { name, arguments: args } = request.params;
try {
const { allPrompts } = await import('./prompts/index.js');
const prompt = allPrompts.find(p => p.name === name);
if (!prompt) {
throw new McpAdrError(`Unknown prompt: ${name}`, 'UNKNOWN_PROMPT');
}
// Simple template rendering (replace {{variable}} with values)
let renderedTemplate = prompt.template;
if (args) {
for (const [key, value] of Object.entries(args)) {
const regex = new RegExp(`{{${key}}}`, 'g');
renderedTemplate = renderedTemplate.replace(regex, String(value));
}
}
const response = {
description: prompt.description,
messages: [
{
role: 'user',
content: {
type: 'text',
text: renderedTemplate,
},
},
],
};
return await this.applyOutputMasking(response);
} catch (error) {
if (error instanceof McpAdrError) {
throw error;
}
throw new McpAdrError(
`Prompt execution failed: ${error instanceof Error ? error.message : String(error)}`,
'PROMPT_EXECUTION_ERROR'
);
}
});
}
/**
* Tool implementations
*/
private async checkAIExecutionStatus(_args: Record<string, unknown>): Promise<CallToolResult> {
try {
const { getAIExecutionStatus } = await import('./utils/prompt-execution.js');
const status = getAIExecutionStatus();
return {
content: [
{
type: 'text',
text: `# AI Execution Status Diagnostic
## Current Configuration
- **AI Execution Enabled**: ${status.isEnabled ? '✅ YES' : '❌ NO'}
- **Has API Key**: ${status.hasApiKey ? '✅ YES' : '❌ NO'}
- **Execution Mode**: ${status.executionMode}
- **AI Model**: ${status.model}
${
status.reason
? `## ⚠️ Issue Detected
**Problem**: ${status.reason}
## Solution
${
!status.hasApiKey
? `
1. Get an OpenRouter API key from https://openrouter.ai/keys
2. Add it to your MCP configuration:
\`\`\`json
{
"mcpServers": {
"adr-analysis": {
"command": "mcp-adr-analysis-server",
"env": {
"OPENROUTER_API_KEY": "your_api_key_here",
"EXECUTION_MODE": "full",
"AI_MODEL": "anthropic/claude-3-sonnet"
}
}
}
}
\`\`\`
3. Restart your MCP client (Claude Desktop, etc.)
`
: status.executionMode !== 'full'
? `
1. Update your MCP configuration to set EXECUTION_MODE to "full":
\`\`\`json
{
"mcpServers": {
"adr-analysis": {
"env": {
"EXECUTION_MODE": "full"
}
}
}
}
\`\`\`
2. Restart your MCP client
`
: ''
}`
: `## ✅ Configuration Looks Good!
AI execution is properly configured. Tools should return actual results instead of prompts.
If you're still seeing prompts instead of results, try:
1. Restart your MCP client
2. Check your OpenRouter API key has sufficient credits
3. Verify network connectivity to OpenRouter.ai`
}
## Environment Variables Expected
- **OPENROUTER_API_KEY**: Your OpenRouter API key
- **EXECUTION_MODE**: Set to "full" for AI execution
- **AI_MODEL**: AI model to use (optional, defaults to claude-3-sonnet)
## Testing
After fixing the configuration, try calling \`suggest_adrs\` - it should return actual ADR suggestions instead of prompts.
`,
},
],
};
} catch (error) {
return {
content: [
{
type: 'text',
text: `# AI Execution Status Check Failed
**Error**: ${error instanceof Error ? error.message : String(error)}
This diagnostic tool helps identify why tools return prompts instead of actual results.
## Manual Check
Verify these environment variables are set in your MCP configuration:
- OPENROUTER_API_KEY
- EXECUTION_MODE=full
- AI_MODEL (optional)
`,
},
],
};
}
}
private async getWorkflowGuidance(args: GetWorkflowGuidanceArgs): Promise<CallToolResult> {
const {
goal,
projectContext,
availableAssets = [],
timeframe = 'thorough_review',
primaryConcerns = [],
} = args;
try {
const workflowPrompt = `
# Workflow Guidance & Tool Recommendation System
## User Context Analysis
- **Goal**: ${goal}
- **Project Context**: ${projectContext}
- **Available Assets**: ${availableAssets.length > 0 ? availableAssets.join(', ') : 'None specified'}
- **Timeframe**: ${timeframe}
- **Primary Concerns**: ${primaryConcerns.length > 0 ? primaryConcerns.join(', ') : 'General analysis'}
## Available MCP Tools (24 Total)
### 🎯 **Core Analysis Tools** (AI-Powered ✅)
1. **analyze_project_ecosystem** - Comprehensive technology and pattern detection
2. **get_architectural_context** - Generate intelligent architectural insights + ADR setup
3. **generate_adrs_from_prd** - Convert requirements to structured ADRs
4. **analyze_content_security** - Detect sensitive information patterns
### 📋 **ADR Management Tools** (AI-Powered ✅)
5. **suggest_adrs** - Auto-suggest ADRs from implicit decisions
6. **generate_adr_from_decision** - Create ADRs from specific decisions
7. **discover_existing_adrs** - Intelligent ADR discovery and analysis
### 🔍 **Research & Documentation Tools** (AI-Powered ✅)
8. **generate_research_questions** - Create context-aware research questions
9. **incorporate_research** - Integrate research findings into decisions
10. **create_research_template** - Generate research documentation templates
### 🛡️ **Security & Compliance Tools** (AI-Powered ✅)
11. **generate_content_masking** - Intelligent content masking and protection
12. **configure_custom_patterns** - Customize security and masking settings
13. **apply_basic_content_masking** - Basic content masking (fallback)
14. **validate_content_masking** - Validate masking effectiveness
### 🏗️ **Rule & Governance Tools** (AI-Powered ✅)
16. **generate_rules** - Extract architectural rules from ADRs
17. **validate_rules** - Validate code against architectural rules
18. **create_rule_set** - Create comprehensive rule management systems
### 🚀 **Deployment & Environment Tools** (AI-Powered ✅)
19. **analyze_environment** - Environment analysis and optimization
20. **analyze_deployment_progress** - Deployment tracking and verification
### ⚙️ **Utility & Management Tools**
21. **manage_cache** - Cache management and optimization
22. **configure_output_masking** - Configure global output masking
23. **request_action_confirmation** - Interactive user confirmation workflows
24. **get_workflow_guidance** - This tool - intelligent workflow advisor
## Workflow Recommendation Instructions
Based on the user's goal, project context, available assets, timeframe, and concerns, provide:
### 1. **Recommended Tool Sequence**
Provide a step-by-step workflow with:
- **Tool Name**: Exact tool to call
- **Purpose**: Why this tool is needed
- **Expected Outcome**: What it will deliver
- **Parameters**: Suggested parameters for the tool call
- **Success Criteria**: How to know it worked
### 2. **Alternative Workflows**
Provide 2-3 alternative approaches based on:
- Different time constraints
- Different priorities
- Different starting points
### 3. **Expected Timeline & Effort**
For each recommended workflow:
- **Estimated Time**: How long each step takes
- **Effort Level**: Low/Medium/High effort required
- **Dependencies**: Which steps must be completed first
### 4. **Success Metrics**
Define how to measure success:
- **Immediate Indicators**: Quick wins and early signals
- **Progress Milestones**: Key checkpoints
- **Final Outcomes**: Ultimate success criteria
### 5. **Common Pitfalls & Tips**
- **What to Avoid**: Common mistakes in this workflow
- **Pro Tips**: Best practices for maximum effectiveness
- **Troubleshooting**: What to do if steps fail
## Common Workflow Patterns
### **New Project Setup**
1. analyze_project_ecosystem → 2. get_architectural_context → 3. suggest_adrs → 4. generate_adr_from_decision
### **Existing Project Analysis**
1. discover_existing_adrs → 2. get_architectural_context → 3. validate_rules
### **Security Audit**
1. analyze_content_security → 2. generate_content_masking → 3. configure_custom_patterns → 4. validate_content_masking
### **PRD to Implementation**
1. generate_adrs_from_prd → 2. analyze_deployment_progress
### **Legacy Modernization**
1. analyze_project_ecosystem → 2. get_architectural_context → 3. suggest_adrs → 4. generate_rules → 5. validate_rules
## Output Format
Provide a comprehensive workflow guide that includes:
1. **🎯 Recommended Primary Workflow** (step-by-step with tool calls)
2. **🔄 Alternative Approaches** (2-3 different paths)
3. **⏱️ Timeline & Effort Estimates** (realistic expectations)
4. **📊 Success Metrics** (how to measure progress)
5. **💡 Pro Tips & Best Practices** (maximize effectiveness)
6. **⚠️ Common Pitfalls** (what to avoid)
Make the guidance **actionable, specific, and outcome-focused** so the user can immediately start executing the recommended workflow.
`;
// Execute the workflow guidance with AI if enabled
const { executePromptWithFallback, formatMCPResponse } = await import(
'./utils/prompt-execution.js'
);
const executionResult = await executePromptWithFallback(
workflowPrompt,
'Analyze the user context and provide intelligent workflow guidance with specific tool recommendations.',
{
temperature: 0.1,
maxTokens: 6000,
systemPrompt: `You are an expert workflow advisor for the MCP ADR Analysis Server.
Your role is to analyze user goals and project context, then recommend the optimal sequence of tools to achieve their objectives efficiently.
Provide specific, actionable guidance with clear tool sequences, expected outcomes, and success criteria.
Focus on practical workflows that deliver measurable results.`,
}
);
if (executionResult.isAIGenerated) {
// AI execution successful - return actual workflow guidance
return formatMCPResponse({
...executionResult,
content: `# Workflow Guidance & Tool Recommendations
## Your Context
- **Goal**: ${goal}
- **Project Context**: ${projectContext}
- **Available Assets**: ${availableAssets.length > 0 ? availableAssets.join(', ') : 'None specified'}
- **Timeframe**: ${timeframe}
- **Primary Concerns**: ${primaryConcerns.length > 0 ? primaryConcerns.join(', ') : 'General analysis'}
## AI-Generated Workflow Guidance
${executionResult.content}
## Quick Reference: Available Tools
**Core Analysis**: analyze_project_ecosystem, get_architectural_context, generate_adrs_from_prd, analyze_content_security
**ADR Management**: suggest_adrs, generate_adr_from_decision, discover_existing_adrs
**Security**: generate_content_masking, configure_custom_patterns, validate_content_masking
**Governance**: generate_rules, validate_rules, create_rule_set
**Environment**: analyze_environment, analyze_deployment_progress
**Utilities**: manage_cache, configure_output_masking, check_ai_execution_status
## Next Steps
1. **Start with the recommended primary workflow** above
2. **Call the first tool** with the suggested parameters
3. **Review the results** and proceed to the next step
4. **Track progress** using the success metrics provided
5. **Adjust as needed** based on your specific findings
This guidance is tailored to your specific context and goals for maximum effectiveness!
`,
});
} else {
// Fallback to prompt-only mode
return {
content: [
{
type: 'text',
text: workflowPrompt,
},
],
};
}
} catch (error) {
throw new McpAdrError(
`Failed to generate workflow guidance: ${error instanceof Error ? error.message : String(error)}`,
'WORKFLOW_ERROR'
);
}
}
private async getDevelopmentGuidance(args: GetDevelopmentGuidanceArgs): Promise<CallToolResult> {
const {
developmentPhase,
adrsToImplement = [],
technologyStack = [],
currentProgress = '',
teamContext = { size: 'small_team', experienceLevel: 'mixed' },
timeline = '',
focusAreas = [],
} = args;
try {
// Use actual ADR discovery if ADRs are specified
let adrAnalysisPrompt = '';
if (adrsToImplement.length > 0) {
const { getAdrDirectoryPath } = await import('./utils/config.js');
const { discoverAdrsInDirectory } = await import('./utils/adr-discovery.js');
const absoluteAdrPath = getAdrDirectoryPath(this.config);
const discoveryResult = await discoverAdrsInDirectory(
absoluteAdrPath,
true,
this.config.projectPath
);
// Filter ADRs to only those specified for implementation
const targetAdrs = discoveryResult.adrs.filter(adr =>
adrsToImplement.some(
(target: string) =>
adr.title.toLowerCase().includes(target.toLowerCase()) ||
adr.filename.toLowerCase().includes(target.toLowerCase())
)
);
adrAnalysisPrompt = `
## ADR Analysis for Implementation
**ADRs to Implement**: ${adrsToImplement.join(', ')}
**ADR Directory**: ${absoluteAdrPath}
**Found ${targetAdrs.length} matching ADRs**
${targetAdrs
.map(
adr => `
### ${adr.title}
- **File**: ${adr.filename}
- **Status**: ${adr.status}
- **Context**: ${adr.context}
- **Decision**: ${adr.decision}
- **Consequences**: ${adr.consequences}
`
)
.join('\n')}
`;
}
const developmentPrompt = `
# Development Guidance & Implementation Roadmap
## Development Context
- **Development Phase**: ${developmentPhase}
- **Technology Stack**: ${technologyStack.length > 0 ? technologyStack.join(', ') : 'Not specified'}
- **Current Progress**: ${currentProgress || 'Starting fresh'}
- **Team Size**: ${teamContext.size}
- **Team Experience**: ${teamContext.experienceLevel}
- **Timeline**: ${timeline || 'Not specified'}
- **Focus Areas**: ${focusAreas.length > 0 ? focusAreas.join(', ') : 'General development'}
${adrAnalysisPrompt}
## Development Guidance Instructions
Based on the development context, ADRs to implement, and technology stack, provide comprehensive development guidance including:
### 1. **Implementation Roadmap**
Create a detailed development plan with:
- **Phase-by-Phase Breakdown**: Logical development phases
- **Task Prioritization**: Order tasks by dependencies and impact
- **Milestone Definition**: Clear checkpoints and deliverables
- **Risk Assessment**: Potential blockers and mitigation strategies
### 2. **Code Structure & Architecture**
Provide specific guidance on:
- **Project Structure**: How to organize code files and directories
- **Module Architecture**: How to structure components/modules
- **Design Patterns**: Which patterns to use and where
- **Code Organization**: Separation of concerns and layering
### 3. **Implementation Patterns & Best Practices**
For each technology in the stack, provide:
- **Framework-Specific Patterns**: Best practices for the chosen frameworks
- **API Design**: How to structure APIs and endpoints
- **Data Layer**: Database schema and data access patterns
- **State Management**: How to handle application state
- **Error Handling**: Consistent error handling strategies
### 4. **ADR-to-Code Translation**
For each ADR to implement:
- **Implementation Tasks**: Specific coding tasks derived from the ADR
- **Code Examples**: Pseudo-code or pattern examples
- **Integration Points**: How this ADR affects other parts of the system
- **Validation Criteria**: How to verify the ADR is properly implemented
### 5. **Testing Strategy**
Comprehensive testing approach:
- **Unit Testing**: What to test and how
- **Integration Testing**: API and component integration tests
- **End-to-End Testing**: User workflow testing
- **Performance Testing**: Load and performance validation
- **Security Testing**: Security validation approaches
### 6. **Development Workflow**
Team-specific guidance:
- **Git Workflow**: Branching strategy and code review process
- **CI/CD Pipeline**: Automated testing and deployment
- **Code Quality**: Linting, formatting, and quality gates
- **Documentation**: What to document and how
### 7. **Quality Gates & Checkpoints**
Define success criteria:
- **Code Quality Metrics**: Coverage, complexity, maintainability
- **Performance Benchmarks**: Response times, throughput targets
- **Security Checkpoints**: Security validation at each phase
- **Architectural Compliance**: Adherence to ADR decisions
### 8. **Technology-Specific Implementation**
For each technology in the stack, provide:
- **Setup Instructions**: Environment and tooling setup
- **Configuration**: Framework and tool configuration
- **Optimization**: Performance and build optimization
- **Deployment**: Technology-specific deployment considerations
## Expected Output Format
Provide a comprehensive development guide that includes:
### 📋 **1. Development Roadmap**
- **Phase 1-N**: Logical development phases with tasks
- **Dependencies**: Task dependencies and critical path
- **Timeline**: Estimated effort and duration
- **Milestones**: Key deliverables and checkpoints
### 🏗️ **2. Implementation Guide**
- **Code Structure**: Detailed project organization
- **Design Patterns**: Specific patterns to implement
- **API Design**: Endpoint structure and conventions
- **Data Architecture**: Database and data flow design
### 🧪 **3. Testing & Quality Strategy**
- **Test Types**: Unit, integration, e2e testing approach
- **Quality Gates**: Code quality and performance criteria
- **Automation**: CI/CD and automated testing setup
### 🚀 **4. Deployment & Operations**
- **Environment Setup**: Development, staging, production
- **Deployment Pipeline**: Automated deployment process
- **Monitoring**: Logging, metrics, and alerting
- **Maintenance**: Ongoing maintenance and updates
### 📊 **5. Progress Tracking**
- **Success Metrics**: How to measure development progress
- **Quality Indicators**: Code quality and performance metrics
- **Milestone Validation**: How to verify milestone completion
- **Risk Monitoring**: Early warning signs and mitigation
### 💡 **6. Team-Specific Recommendations**
Based on team size (${teamContext.size}) and experience (${teamContext.experienceLevel}):
- **Workflow Adaptations**: Process adjustments for team context
- **Skill Development**: Areas for team skill building
- **Tool Recommendations**: Development tools and practices
- **Communication**: Coordination and documentation practices
## Integration with Architectural Decisions
Ensure all development guidance:
- **Aligns with ADRs**: Every recommendation supports architectural decisions
- **Maintains Consistency**: Consistent patterns across the codebase
- **Enables Evolution**: Flexible design for future changes
- **Supports Quality**: Built-in quality and maintainability
Make the guidance **actionable, specific, and immediately implementable** so developers can start coding with confidence and architectural alignment.
`;
// Execute the development guidance with AI if enabled
const { executePromptWithFallback, formatMCPResponse } = await import(
'./utils/prompt-execution.js'
);
const executionResult = await executePromptWithFallback(
developmentPrompt,
'Analyze the development context and provide comprehensive implementation guidance that translates architectural decisions into specific coding tasks and development roadmap.',
{
temperature: 0.1,
maxTokens: 8000,
systemPrompt: `You are an expert software development advisor specializing in translating architectural decisions into practical implementation guidance.
Your role is to bridge the gap between architectural planning and actual code development.
Provide specific, actionable development guidance with clear implementation steps, code patterns, and quality criteria.
Focus on practical guidance that ensures architectural decisions are properly implemented in code.
Consider team context, technology stack, and development phase to provide tailored recommendations.`,
}
);
if (executionResult.isAIGenerated) {
// AI execution successful - return actual development guidance
return formatMCPResponse({
...executionResult,
content: `# Development Guidance & Implementation Roadmap
## Your Development Context
- **Development Phase**: ${developmentPhase}
- **Technology Stack**: ${technologyStack.length > 0 ? technologyStack.join(', ') : 'Not specified'}
- **Current Progress**: ${currentProgress || 'Starting fresh'}
- **Team Context**: ${teamContext.size} team with ${teamContext.experienceLevel} experience
- **Timeline**: ${timeline || 'Not specified'}
- **Focus Areas**: ${focusAreas.length > 0 ? focusAreas.join(', ') : 'General development'}
- **ADRs to Implement**: ${adrsToImplement.length > 0 ? adrsToImplement.join(', ') : 'None specified'}
## AI-Generated Development Guidance
${executionResult.content}
## Integration with Workflow Tools
This development guidance works seamlessly with other MCP tools:
### **Workflow Integration**
1. **get_workflow_guidance** → Recommends architectural process
2. **get_development_guidance** → Guides implementation (this tool)
3. **validate_rules** → Ensures code follows architectural decisions
4. **analyze_deployment_progress** → Tracks implementation progress
### **Quality Assurance Tools**
- **generate_rules** → Extract coding standards from ADRs
- **validate_rules** → Validate code against architectural rules
- **analyze_content_security** → Security validation during development
### **Documentation Tools**
- **discover_existing_adrs** → Reference existing architectural decisions
## Next Steps: From Architecture to Code
1. **📋 Review the Development Roadmap** above
2. **🏗️ Set Up Project Structure** as recommended
3. **🧪 Implement Testing Strategy** early in development
4. **📊 Track Progress** using the success metrics provided
5. **🔄 Iterate and Refine** based on implementation learnings
This guidance ensures your development work is **architecturally aligned**, **quality-focused**, and **efficiently executed**!
`,
});
} else {
// Fallback to prompt-only mode
return {
content: [
{
type: 'text',
text: developmentPrompt,
},
],
};
}
} catch (error) {
throw new McpAdrError(
`Failed to generate development guidance: ${error instanceof Error ? error.message : String(error)}`,
'DEVELOPMENT_ERROR'
);
}
}
private async analyzeProjectEcosystem(
args: AnalyzeProjectEcosystemArgs,
context?: ToolContext
): Promise<CallToolResult> {
const ctx = context || createNoOpContext();
// Use configured project path if not provided in args
const projectPath = args.projectPath || this.config.projectPath;
const {
includePatterns,
enhancedMode = true,
knowledgeEnhancement = true,
learningEnabled = true,
technologyFocus = [],
analysisDepth = 'comprehensive',
includeEnvironment = true,
recursiveDepth = 'comprehensive',
analysisScope = [],
// conversationContext - TODO: implement context integration for ecosystem analysis
} = args;
this.logger.info(`Generating comprehensive ecosystem analysis for project at: ${projectPath}`);
this.logger.info(
`Analysis configuration - Depth: ${analysisDepth}, Recursive: ${recursiveDepth}, Environment: ${includeEnvironment}`
);
this.logger.info(
`Enhancement features - Knowledge: ${knowledgeEnhancement}, Learning: ${learningEnabled}`
);
this.logger.info(
`Analysis scope: ${analysisScope.length > 0 ? analysisScope.join(', ') : 'Full ecosystem analysis'}`
);
ctx.info(`🌐 Starting comprehensive ecosystem analysis: ${projectPath}`);
ctx.report_progress(0, 100);
try {
ctx.info('📊 Phase 1: Analyzing project structure');
ctx.report_progress(10, 100);
// Import utilities dynamically to avoid circular dependencies
const { analyzeProjectStructureCompat: analyzeProjectStructure } = await import(
'./utils/file-system.js'
);
// Initialize ADR knowledge base on first run
ctx.info('📚 Phase 1.5: Initializing ADR knowledge base');
ctx.report_progress(15, 100);
try {
const { initializeAdrKnowledgeBase, isAdrKnowledgeBaseInitialized } = await import(
'./utils/adr-knowledge-initializer.js'
);
const isInitialized = await isAdrKnowledgeBaseInitialized(this.kgManager);
if (!isInitialized) {
this.logger.info('First run detected - initializing ADR knowledge base');
const initResult = await initializeAdrKnowledgeBase(
this.kgManager,
this.config.adrDirectory,
projectPath
);
if (initResult.success) {
this.logger.info(
`✅ ADR knowledge base initialized with ${initResult.adrsIndexed} ADRs`
);
ctx.info(`📚 Indexed ${initResult.adrsIndexed} existing ADRs to knowledge base`);
} else {
this.logger.warn(
`ADR knowledge base initialization completed with errors: ${initResult.errors.join(', ')}`
);
}
} else {
this.logger.info('ADR knowledge base already initialized - skipping');
}
} catch (error) {
this.logger.warn('Failed to initialize ADR knowledge base:', error);
// Don't fail the entire analysis if ADR initialization fails
}
// Import advanced prompting utilities if enhanced mode is enabled
let generateArchitecturalKnowledge: GenerateArchitecturalKnowledgeFunction | null = null;
let executeWithReflexion: ExecuteWithReflexionFunction | null = null;
let retrieveRelevantMemories: RetrieveRelevantMemoriesFunction | null = null;
let createToolReflexionConfig: CreateToolReflexionConfigFunction | null = null;
if (enhancedMode) {
if (knowledgeEnhancement) {
const knowledgeModule = await import('./utils/knowledge-generation.js');
generateArchitecturalKnowledge = knowledgeModule.generateArchitecturalKnowledge;
}
if (learningEnabled) {
const reflexionModule = await import('./utils/reflexion.js');
executeWithReflexion = reflexionModule.executeWithReflexion;
retrieveRelevantMemories = reflexionModule.retrieveRelevantMemories;
createToolReflexionConfig = reflexionModule.createToolReflexionConfig;
}
}
// Step 1: Generate technology-specific knowledge if enabled
ctx.info('🧠 Phase 2: Generating architectural knowledge');
ctx.report_progress(25, 100);
let knowledgeContext = '';
if (enhancedMode && knowledgeEnhancement && generateArchitecturalKnowledge) {
try {
const knowledgeResult = await generateArchitecturalKnowledge(
{
projectPath,
technologies: technologyFocus,
patterns: [],
projectType: 'ecosystem-analysis',
existingAdrs: [],
},
{
domains: this.getEcosystemAnalysisDomains(technologyFocus) as ArchitecturalDomain[],
depth: analysisDepth === 'basic' ? 'basic' : 'intermediate',
cacheEnabled: true,
}
);
knowledgeContext = `
## Technology-Specific Knowledge Enhancement
The following architectural knowledge has been generated to enhance ecosystem analysis:
${knowledgeResult.prompt}
---
`;
} catch (error) {
this.logger.warn('Knowledge generation failed:', error);
knowledgeContext = '<!-- Knowledge generation unavailable -->\n';
}
}
// Step 2: Retrieve relevant memories if learning is enabled
let reflexionContext = '';
if (enhancedMode && learningEnabled && retrieveRelevantMemories) {
try {
const memoryResult = await retrieveRelevantMemories(
'ecosystem-analysis',
{ projectPath, analysisDepth, technologyFocus },
{ maxResults: 5, relevanceThreshold: 0.6 }
);
reflexionContext = `
## Learning from Past Analyses
The following insights from past ecosystem analysis tasks will inform this analysis:
${memoryResult.prompt}
---
`;
} catch (error) {
this.logger.warn('Reflexion memory retrieval failed:', error);
reflexionContext = '<!-- Learning context unavailable -->\n';
}
}
// Step 3: Generate base project analysis prompt with recursive depth
ctx.info('📁 Phase 3: Scanning project files and structure');
ctx.report_progress(40, 100);
const baseProjectAnalysisPrompt = await analyzeProjectStructure(projectPath);
// Step 4: Generate environment analysis if enabled
ctx.info('🔧 Phase 4: Analyzing environment and infrastructure');
ctx.report_progress(55, 100);
let environmentAnalysisContext = '';
if (includeEnvironment) {
try {
this.logger.info('Including comprehensive environment analysis in ecosystem analysis');
const { analyzeEnvironment } = await import('./tools/environment-analysis-tool.js');
// Call environment analysis with comprehensive scope
const environmentResult = await analyzeEnvironment({
projectPath,
adrDirectory: this.config.adrDirectory,
analysisType: 'comprehensive',
});
// Extract environment analysis content
if (environmentResult.content && environmentResult.content[0]) {
environmentAnalysisContext = `
## Integrated Environment Analysis
${environmentResult.content[0].text}
---
`;
}
} catch (error) {
this.logger.warn('Environment analysis integration failed:', error);
environmentAnalysisContext = `
## Environment Analysis
<!-- Environment analysis unavailable: ${error instanceof Error ? error.message : 'Unknown error'} -->
---
`;
}
}
// Step 5: Apply Reflexion execution if learning is enabled
ctx.info('🧪 Phase 5: Applying learning and reflexion');
ctx.report_progress(70, 100);
let enhancedAnalysisPrompt = baseProjectAnalysisPrompt.prompt + environmentAnalysisContext;
if (enhancedMode && learningEnabled && executeWithReflexion && createToolReflexionConfig) {
try {
const reflexionConfig = createToolReflexionConfig('analyze_project_ecosystem', {
reflectionDepth: analysisDepth === 'basic' ? 'basic' : 'detailed',
evaluationCriteria: ['task-success', 'accuracy', 'completeness'],
learningRate: 0.7,
});
const reflexionResult = await executeWithReflexion(
{
prompt:
baseProjectAnalysisPrompt.prompt + knowledgeContext + environmentAnalysisContext,
instructions: baseProjectAnalysisPrompt.instructions,
context: {
projectPath,
analysisDepth,
recursiveDepth,
technologyFocus,
includePatterns,
includeEnvironment,
analysisScope,
knowledgeEnhanced: knowledgeEnhancement,
learningEnabled: true,
},
},
reflexionConfig
);
enhancedAnalysisPrompt = reflexionResult.prompt;
} catch (error) {
this.logger.warn('Reflexion execution failed:', error);
enhancedAnalysisPrompt =
baseProjectAnalysisPrompt.prompt + knowledgeContext + environmentAnalysisContext;
}
} else {
enhancedAnalysisPrompt =
baseProjectAnalysisPrompt.prompt + knowledgeContext + environmentAnalysisContext;
}
// Execute the analysis with AI if enabled, otherwise return prompt
ctx.info('🤖 Phase 6: Executing AI-powered ecosystem analysis');
ctx.report_progress(85, 100);
const { executeEcosystemAnalysisPrompt, formatMCPResponse } = await import(
'./utils/prompt-execution.js'
);
const executionResult = await executeEcosystemAnalysisPrompt(
enhancedAnalysisPrompt,
baseProjectAnalysisPrompt.instructions,
{
temperature: 0.1,
maxTokens: 6000,
}
);
// Step 6: Record project structure to knowledge graph
try {
this.logger.info('Recording project structure to knowledge graph');
const projectStructureSnapshot = {
projectPath,
analysisDepth,
recursiveDepth,
technologyFocus,
analysisScope,
includeEnvironment,
timestamp: new Date().toISOString(),
structureData: baseProjectAnalysisPrompt.context || {},
};
await this.kgManager.recordProjectStructure(projectStructureSnapshot);
this.logger.info('✅ Project structure recorded to knowledge graph');
} catch (kgError) {
this.logger.warn('Failed to record project structure to knowledge graph:', kgError);
// Don't fail the entire analysis if KG recording fails
}
ctx.info('✅ Ecosystem analysis completed successfully');
ctx.report_progress(100, 100);
// Return appropriate response based on execution result
if (executionResult.isAIGenerated) {
// AI execution successful - return actual analysis results
return formatMCPResponse({
...executionResult,
content: `# Comprehensive Project Ecosystem Analysis Results
## Analysis Configuration
- **Project Path**: ${projectPath}
- **Analysis Depth**: ${analysisDepth}
- **Recursive Depth**: ${recursiveDepth}
- **Environment Analysis**: ${includeEnvironment ? '✅ Included' : '❌ Excluded'}
- **Analysis Scope**: ${analysisScope.length > 0 ? analysisScope.join(', ') : 'Full ecosystem analysis'}
## Enhancement Features
- **Knowledge Generation**: ${enhancedMode && knowledgeEnhancement ? '✅ Enabled' : '❌ Disabled'}
- **Reflexion Learning**: ${enhancedMode && learningEnabled ? '✅ Enabled' : '❌ Disabled'}
- **Enhanced Mode**: ${enhancedMode ? '✅ Enabled' : '❌ Disabled'}
- **Technology Focus**: ${technologyFocus.length > 0 ? technologyFocus.join(', ') : 'Auto-detect'}
- **Knowledge Graph**: ✅ Project structure recorded
${knowledgeContext}
${reflexionContext}
## Comprehensive Ecosystem Analysis Results
${executionResult.content}
${
includeEnvironment
? `
## Environment Integration Summary
The analysis above includes comprehensive environment analysis covering:
- **Infrastructure Specifications**: Deployment and runtime environment details
- **Containerization**: Docker, Kubernetes, and container orchestration analysis
- **Environment Requirements**: Configuration and dependency requirements
- **Compliance Assessment**: Security and regulatory compliance evaluation
This integrated approach provides complete understanding of both codebase patterns AND operational environment.
`
: ''
}
## Next Steps: Complete Ecosystem Understanding
Based on the comprehensive analysis above:
### **Immediate Actions**
1. **Review Ecosystem Overview**: Examine the complete technology stack and environment context
2. **Assess Integration Points**: Understand how code patterns relate to operational environment
3. **Identify Critical Dependencies**: Focus on key dependencies between code and infrastructure
### **Strategic Planning**
4. **Address Architectural Issues**: Prioritize improvements based on both code and environment analysis
5. **Plan Environment Optimization**: Optimize deployment and operational configurations
6. **Update Documentation**: Document both architectural decisions and environment specifications
### **Implementation Roadmap**
7. **Implement Code Improvements**: Execute code-level architectural enhancements
8. **Optimize Environment**: Improve infrastructure and deployment configurations
9. **Monitor Integration**: Ensure code and environment changes work together effectively
This comprehensive ecosystem analysis provides the foundation for informed architectural and operational decisions.
`,
});
} else {
// Fallback to prompt-only mode
return {
content: [
{
type: 'text',
text: `# Comprehensive Project Ecosystem Analysis
This comprehensive analysis provides deep recursive project understanding with integrated environment analysis.
## Analysis Configuration
- **Project Path**: ${projectPath}
- **Analysis Depth**: ${analysisDepth}
- **Recursive Depth**: ${recursiveDepth}
- **Environment Analysis**: ${includeEnvironment ? '✅ Included' : '❌ Excluded'}
- **Analysis Scope**: ${analysisScope.length > 0 ? analysisScope.join(', ') : 'Full ecosystem analysis'}
## Enhancement Features
- **Knowledge Generation**: ${enhancedMode && knowledgeEnhancement ? '✅ Enabled' : '❌ Disabled'}
- **Reflexion Learning**: ${enhancedMode && learningEnabled ? '✅ Enabled' : '❌ Disabled'}
- **Enhanced Mode**: ${enhancedMode ? '✅ Enabled' : '❌ Disabled'}
- **Technology Focus**: ${technologyFocus.length > 0 ? technologyFocus.join(', ') : 'Auto-detect'}
- **Include Patterns**: ${includePatterns?.length ? includePatterns.join(', ') : 'Default patterns'}
- **Knowledge Graph**: ✅ Project structure recorded
${knowledgeContext}
${reflexionContext}
## Enhanced Analysis Prompt
${enhancedAnalysisPrompt}
## Enhanced Implementation Instructions
${baseProjectAnalysisPrompt.instructions}
### Enhancement-Specific Instructions
${
enhancedMode && knowledgeEnhancement
? `
#### Knowledge Enhancement
- Apply technology-specific knowledge to ecosystem analysis
- Use domain expertise to identify patterns and anti-patterns
- Leverage architectural best practices for technology stack evaluation
`
: ''
}
${
enhancedMode && learningEnabled
? `
#### Learning Integration
- Apply lessons learned from past ecosystem analyses
- Use memory insights to improve pattern recognition accuracy
- Incorporate feedback from previous analysis outcomes
`
: ''
}
## Expected Enhanced Output
The enhanced analysis should provide:
1. **Technology Stack Analysis** with domain knowledge context
2. **Architectural Pattern Detection** informed by past experiences
3. **Ecosystem Health Assessment** using learned evaluation criteria
4. **Improvement Recommendations** based on domain best practices
5. **Learning Insights** for future analysis improvement
## Quality Assurance
- Ensure analysis leverages all available enhancement features
- Verify technology-specific knowledge is properly applied
- Confirm learning insights improve analysis accuracy
- Validate recommendations align with domain best practices`,
},
],
};
}
} catch (error) {
throw new McpAdrError(
`Failed to analyze project ecosystem: ${error instanceof Error ? error.message : String(error)}`,
'ANALYSIS_ERROR'
);
}
}
private async getArchitecturalContext(
args: GetArchitecturalContextArgs
): Promise<CallToolResult> {
const { filePath, includeCompliance = true } = args;
try {
const {
analyzeProjectStructureCompat: analyzeProjectStructure,
fileExistsCompat: fileExists,
ensureDirectoryCompat: ensureDirectory,
} = await import('./utils/file-system.js');
const path = await import('path');
// Determine project path
const projectPath = filePath
? filePath.split('/').slice(0, -1).join('/')
: this.config.projectPath;
const adrDirectory = path.join(projectPath, this.config.adrDirectory);
// Generate prompts for ADR directory setup
const adrDirectoryCheckPrompt = await fileExists(adrDirectory);
const adrDirectorySetupPrompt = await ensureDirectory(adrDirectory);
// Generate architectural analysis prompt
const projectAnalysisPrompt = await analyzeProjectStructure(projectPath);
const architecturalPrompt = `
# Architectural Context Analysis & Project Setup
## Project Overview
**Project Path**: ${projectPath}
**Analysis Scope**: ${filePath ? `Specific file: ${filePath}` : 'Entire project'}
**ADR Directory**: ${this.config.adrDirectory}
**Include Compliance**: ${includeCompliance ? 'Yes' : 'No'}
## 🚀 ADR Infrastructure Setup
This analysis will include setting up ADR infrastructure if needed:
### ADR Directory Check
${adrDirectoryCheckPrompt.prompt}
### ADR Directory Setup (if needed)
${adrDirectorySetupPrompt.prompt}
## Comprehensive Project Analysis
${projectAnalysisPrompt.prompt}
## Enhanced Architectural Focus
Please provide a **comprehensive, outcome-focused analysis** including:
### 1. Technology Stack & Infrastructure Analysis
- **Core Technologies**: Programming languages, frameworks, runtime environments
- **Dependencies**: Package managers, third-party libraries, version constraints
- **Build & Deployment**: CI/CD pipelines, build tools, deployment strategies
- **Data Layer**: Databases, caching, data storage and retrieval patterns
### 2. Architectural Pattern & Design Analysis
- **System Architecture**: Monolith, microservices, serverless, hybrid patterns
- **Code Organization**: Module structure, separation of concerns, layering
- **API Design**: REST, GraphQL, RPC patterns and conventions
- **Data Flow**: Request/response cycles, event handling, state management
${filePath ? `- **File-specific Context**: How ${filePath} fits into the overall architecture` : ''}
### 3. Quality, Security & Performance Assessment
- **Code Quality**: Structure, naming, documentation, testing strategies
- **Security Implementation**: Authentication, authorization, data protection
- **Performance Patterns**: Caching, optimization, scalability considerations
- **Monitoring & Observability**: Logging, metrics, error tracking
### 4. Architectural Decision Discovery & Documentation
- **Explicit Decisions**: Find existing documentation and decision records
- **Implicit Decisions**: Identify significant undocumented architectural choices
- **Technology Rationale**: Understand selection criteria and trade-offs
- **Evolution Path**: How the architecture has changed over time
${
includeCompliance
? `### 5. Compliance & Standards Assessment
- **Industry Standards**: Adherence to relevant industry standards and best practices
- **Security Compliance**: Security standards compliance (OWASP, SOC2, etc.)
- **Code Standards**: Coding standards and style guide compliance
- **Architectural Compliance**: Adherence to established architectural principles
- **Regulatory Requirements**: Any regulatory compliance requirements (GDPR, HIPAA, etc.)`
: ''
}
## Expected Output: Outcome-Focused Architectural Context
Provide a **comprehensive architectural context** with **clear project outcomes**:
### 📋 **1. Executive Summary & Project Outcomes**
- **Current State**: What the project is and what it does
- **Architectural Maturity**: Assessment of current architectural practices
- **Key Strengths**: What's working well architecturally
- **Critical Gaps**: What needs immediate attention
- **Success Metrics**: How to measure architectural improvements
### 🔧 **2. Technology & Infrastructure Inventory**
- **Technology Stack**: Complete inventory with versions and purposes
- **Infrastructure Components**: Deployment, monitoring, data storage
- **Dependencies**: Critical dependencies and potential risks
- **Tool Chain**: Development, testing, and deployment tools
### 🏗️ **3. Architectural Patterns & Design Decisions**
- **System Design**: Overall architectural approach and patterns
- **Component Architecture**: How major components interact
- **Data Architecture**: How data flows and is managed
- **Integration Patterns**: How external systems are integrated
### 📊 **4. Quality & Compliance Assessment**
- **Code Quality Score**: Assessment of current code quality
- **Security Posture**: Security implementation and gaps
- **Performance Profile**: Current performance characteristics
- **Maintainability Index**: How easy the system is to maintain and evolve
### 🎯 **5. Outcome-Focused Action Plan**
Based on the analysis, provide a **clear workflow** with **projected outcomes**:
#### **Immediate Actions (Next 1-2 weeks)**
- **Priority 1**: Most critical architectural issues to address
- **Quick Wins**: Low-effort, high-impact improvements
- **Documentation**: Essential decisions that need immediate documentation
#### **Short-term Goals (Next 1-3 months)**
- **Architectural Improvements**: Planned enhancements with expected outcomes
- **Technical Debt**: Priority technical debt to address
- **Process Improvements**: Development workflow enhancements
#### **Long-term Vision (3-12 months)**
- **Strategic Architecture**: Long-term architectural evolution
- **Scalability Roadmap**: How to scale the system effectively
- **Innovation Opportunities**: Areas for architectural innovation
### 📈 **6. Success Metrics & Outcomes**
Define **measurable outcomes** for architectural improvements:
- **Performance Metrics**: Response times, throughput, resource utilization
- **Quality Metrics**: Code coverage, bug rates, maintainability scores
- **Developer Experience**: Build times, deployment frequency, developer satisfaction
- **Business Impact**: Feature delivery speed, system reliability, cost efficiency
### 🏗️ **7. ADR Infrastructure & Documentation Plan**
If ADR directory doesn't exist, also provide:
1. **Create Directory Structure**:
\`\`\`
${this.config.adrDirectory}/
├── 0001-record-architecture-decisions.md (template)
├── README.md (ADR process guide)
└── template.md (ADR template)
\`\`\`
2. **Generate Initial ADRs** for discovered architectural decisions
3. **Create ADR Process Guide** for the team
4. **Establish ADR Workflow** for future decisions
### 🔄 **8. Continuous Improvement Workflow**
Establish ongoing architectural governance:
- **Regular Reviews**: Monthly architectural health checks
- **Decision Documentation**: Process for documenting new architectural decisions
- **Compliance Monitoring**: Ongoing adherence to architectural standards
- **Evolution Planning**: Quarterly architectural roadmap updates
## Next Steps: Grounded Project Workflow
After this analysis, follow this **outcome-focused workflow**:
1. **📋 Review Analysis**: Examine the architectural context and recommendations
2. **🎯 Set Priorities**: Choose 3-5 most impactful improvements based on outcomes
3. **📝 Document Decisions**: Create ADRs for significant architectural choices
4. **🔧 Implement Changes**: Execute improvements in priority order
5. **📊 Measure Progress**: Track success metrics and outcomes
6. **🔄 Iterate**: Regular reviews and continuous improvement
This approach ensures that architectural work is **grounded in measurable outcomes** and **aligned with project success**.
`;
// Execute the analysis with AI if enabled, otherwise return prompt
const { executeEcosystemAnalysisPrompt, formatMCPResponse } = await import(
'./utils/prompt-execution.js'
);
const executionResult = await executeEcosystemAnalysisPrompt(
architecturalPrompt,
projectAnalysisPrompt.instructions,
{
temperature: 0.1,
maxTokens: 5000,
systemPrompt: `You are a senior software architect specializing in architectural context analysis.
Analyze the provided project to understand its architectural patterns, design decisions, and structural organization.
Focus on providing actionable insights about the architecture that can guide development decisions.`,
}
);
if (executionResult.isAIGenerated) {
// AI execution successful - return actual analysis results
return formatMCPResponse({
...executionResult,
content: `# Architectural Context Analysis Results
${filePath ? `## Target File: ${filePath}` : '## Project-wide Analysis'}
## Project Information
- **Project Path**: ${projectPath}
- **Analysis Scope**: ${filePath ? 'File-specific' : 'Project-wide'}
- **ADR Directory**: ${this.config.adrDirectory}
## ADR Infrastructure Setup
The analysis includes automatic ADR infrastructure setup:
${adrDirectoryCheckPrompt.instructions}
${adrDirectorySetupPrompt.instructions}
## AI Analysis Results
${executionResult.content}
## Outcome-Focused Next Steps
Based on the architectural analysis, follow this **grounded workflow**:
### **Immediate Actions (This Week)**
1. **Review Analysis**: Examine the architectural context and recommendations above
2. **Set Up ADRs**: Ensure ADR directory structure is created and ready
3. **Identify Quick Wins**: Focus on low-effort, high-impact improvements
### **Short-term Goals (Next Month)**
4. **Document Key Decisions**: Create ADRs for the most significant architectural choices
5. **Address Critical Issues**: Tackle the highest-priority architectural concerns
6. **Establish Metrics**: Set up measurement for the success metrics identified
### **Long-term Vision (Next Quarter)**
7. **Implement Roadmap**: Execute the architectural improvement plan
8. **Monitor Progress**: Track success metrics and adjust approach as needed
9. **Continuous Improvement**: Establish regular architectural reviews
This **outcome-focused approach** ensures architectural work delivers **measurable value** and keeps the project **grounded in clear objectives**.
`,
});
} else {
// Fallback to prompt-only mode
return {
content: [
{
type: 'text',
text: architecturalPrompt,
},
],
};
}
} catch (error) {
throw new McpAdrError(
`Failed to get architectural context: ${error instanceof Error ? error.message : String(error)}`,
'ANALYSIS_ERROR'
);
}
}
private async generateAdrsFromPrd(
args: Record<string, unknown>,
context?: ToolContext
): Promise<CallToolResult> {
const ctx = context || createNoOpContext();
const {
prdPath,
enhancedMode = true,
promptOptimization = true,
knowledgeEnhancement = true,
prdType = 'general',
} = args;
const outputDirectory = args['outputDirectory'] || this.config.adrDirectory;
this.logger.info(`Generating enhanced ADRs from PRD: ${prdPath} to ${outputDirectory}`);
this.logger.info(
`Enhancement features - APE: ${promptOptimization}, Knowledge: ${knowledgeEnhancement}, Type: ${prdType}`
);
ctx.info(`📝 Starting ADR generation from PRD: ${prdPath}`);
ctx.report_progress(0, 100);
try {
ctx.info('📂 Phase 1: Validating PRD file');
ctx.report_progress(10, 100);
const { readFileContentCompat: readFileContent, fileExistsCompat: fileExists } = await import(
'./utils/file-system.js'
);
// Import advanced prompting utilities if enhanced mode is enabled
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let generateArchitecturalKnowledge: any = null;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let optimizePromptWithAPE: any = null;
// eslint-disable-next-line @typescript-eslint/no-explicit-any
let createToolAPEConfig: any = null;
if (enhancedMode) {
if (knowledgeEnhancement) {
const knowledgeModule = await import('./utils/knowledge-generation.js');
generateArchitecturalKnowledge = knowledgeModule.generateArchitecturalKnowledge;
}
if (promptOptimization) {
const apeModule = await import('./utils/automatic-prompt-engineering.js');
optimizePromptWithAPE = apeModule.optimizePromptWithAPE;
createToolAPEConfig = apeModule.createToolAPEConfig;
}
}
// Generate file existence check prompt
const fileExistsPrompt = await fileExists(prdPath as string);
// Generate file content reading prompt
const fileContentPrompt = await readFileContent(prdPath as string);
ctx.info('📚 Phase 2: Reading PRD content');
ctx.report_progress(25, 100);
// Step 1: Generate domain-specific knowledge if enabled
ctx.info('🧠 Phase 3: Generating domain knowledge');
ctx.report_progress(40, 100);
let knowledgeContext = '';
if (enhancedMode && knowledgeEnhancement && generateArchitecturalKnowledge) {
try {
const knowledgeResult = await generateArchitecturalKnowledge(
{
projectPath: outputDirectory,
technologies: [],
patterns: [],
projectType: prdType,
existingAdrs: [],
},
{
domains: this.getPrdTypeDomains(prdType as string),
depth: 'intermediate',
cacheEnabled: true,
}
);
knowledgeContext = `
## Domain-Specific Knowledge Enhancement
The following architectural knowledge has been generated to enhance PRD analysis and ADR creation:
${knowledgeResult.prompt}
---
`;
} catch (error) {
this.logger.warn('Knowledge generation failed:', error);
knowledgeContext = '<!-- Knowledge generation unavailable -->\n';
}
}
// Step 2: Create base ADR generation prompt
ctx.info('📋 Phase 4: Creating base ADR prompts');
ctx.report_progress(60, 100);
const baseAdrPrompt = this.createBaseAdrPrompt(
prdPath as string,
outputDirectory as string,
knowledgeContext
);
// Step 3: Apply APE optimization if enabled
ctx.info('⚡ Phase 5: Optimizing prompts with APE');
ctx.report_progress(75, 100);
let finalAdrPrompt = baseAdrPrompt;
if (enhancedMode && promptOptimization && optimizePromptWithAPE && createToolAPEConfig) {
try {
const apeConfig = createToolAPEConfig('generate_adrs_from_prd', {
candidateCount: 5,
evaluationCriteria: ['task-completion', 'clarity', 'specificity'],
optimizationRounds: 2,
qualityThreshold: 0.75,
});
const apeResult = await optimizePromptWithAPE(
{
prompt: baseAdrPrompt,
instructions: 'Generate comprehensive ADRs from PRD analysis',
context: {
prdPath,
outputDirectory,
prdType,
knowledgeEnhanced: knowledgeEnhancement,
},
},
apeConfig
);
finalAdrPrompt = apeResult.prompt;
} catch (error) {
this.logger.warn('APE optimization failed:', error);
finalAdrPrompt = baseAdrPrompt;
}
}
// Generate comprehensive ADR creation prompt that includes file operations
const adrPrompt = `
# Enhanced ADR Generation from PRD Request
This is a comprehensive prompt-driven ADR generation process enhanced with advanced prompting techniques.
## Enhancement Status
- **APE Optimization**: ${enhancedMode && promptOptimization ? '✅ Enabled' : '❌ Disabled'}
- **Knowledge Generation**: ${enhancedMode && knowledgeEnhancement ? '✅ Enabled' : '❌ Disabled'}
- **PRD Type**: ${prdType}
- **Enhanced Mode**: ${enhancedMode ? '✅ Enabled' : '❌ Disabled'}
## Step 1: File Validation
${fileExistsPrompt.prompt}
**Instructions**: First, execute the file existence check above. If the file does not exist, stop the process and report the error. Only proceed to Step 2 if the file exists.
## Step 2: PRD Content Reading
${fileContentPrompt.prompt}
**Instructions**: Execute the file reading operation above to obtain the PRD content. Use the content from this step for the enhanced ADR generation in Step 3.
## Step 3: Enhanced ADR Generation
${
enhancedMode && promptOptimization
? `
### APE-Optimized Analysis
This prompt has been optimized using Automatic Prompt Engineering for superior ADR generation quality.
The optimization focused on task completion, clarity, and specificity for PRD analysis.
`
: ''
}
${finalAdrPrompt}
### File Creation Instructions
For each generated ADR, create a file creation prompt using the following pattern:
- **File Path**: ${outputDirectory}/[number]-[decision-title].md
- **Content**: The complete enhanced ADR markdown content
- **Action Confirmation**: Require user confirmation before creating files
- **Security Validation**: Ensure output directory is safe and authorized
### Enhanced Quality Assurance
- Ensure each ADR leverages domain knowledge when available
- Verify decisions align with PRD type best practices
- Check that enhancement features are properly utilized
- Validate that ADR content exceeds baseline quality expectations
- Confirm all decisions are traceable back to PRD requirements with domain context
`;
// Execute the ADR generation with AI if enabled, otherwise return prompt
ctx.info('🤖 Phase 6: Executing AI-powered ADR generation');
ctx.report_progress(90, 100);
const { executeADRGenerationPrompt, formatMCPResponse } = await import(
'./utils/prompt-execution.js'
);
const executionResult = await executeADRGenerationPrompt(
adrPrompt,
'Generate comprehensive ADRs from PRD analysis with enhanced domain knowledge and optimization',
{
temperature: 0.1,
maxTokens: 8000,
systemPrompt: `You are an expert software architect who creates comprehensive Architectural Decision Records (ADRs) from Product Requirements Documents (PRDs).
Generate well-structured ADRs that follow best practices and include all necessary sections.
Focus on extracting architectural decisions from the PRD and creating actionable ADRs with clear reasoning.`,
}
);
ctx.info('✅ ADR generation completed successfully');
ctx.report_progress(100, 100);
if (executionResult.isAIGenerated) {
// AI execution successful - return actual ADR generation results
return formatMCPResponse({
...executionResult,
content: `# ADR Generation from PRD Results
## Enhancement Features
- **APE Optimization**: ${enhancedMode && promptOptimization ? '✅ Enabled' : '❌ Disabled'}
- **Knowledge Generation**: ${enhancedMode && knowledgeEnhancement ? '✅ Enabled' : '❌ Disabled'}
- **PRD Type Optimization**: ${prdType}
- **Enhanced Mode**: ${enhancedMode ? '✅ Enabled' : '❌ Disabled'}
## Source Information
- **PRD Path**: ${prdPath}
- **Output Directory**: ${outputDirectory}
## Generated ADRs
${executionResult.content}
## Next Steps
1. **Review Generated ADRs**: Examine each ADR for completeness and accuracy
2. **Save ADR Files**: Create individual .md files for each ADR in ${outputDirectory}
3. **Update ADR Index**: Add new ADRs to your project's ADR catalog
4. **Stakeholder Review**: Share ADRs with team for feedback and approval
5. **Implementation Planning**: Create tasks for implementing the architectural decisions
## File Creation Commands
To save the generated ADRs, create individual files in ${outputDirectory}:
\`\`\`bash
# Create ADR directory if it doesn't exist
mkdir -p ${outputDirectory}
# Save each ADR as a separate file (example)
# Replace [NUMBER] and [TITLE] with actual values from generated ADRs
# cat > "${outputDirectory}/001-example-decision.md" << 'EOF'
# [ADR content here]
# EOF
\`\`\`
`,
});
} else {
// Fallback to prompt-only mode
return {
content: [
{
type: 'text',
text: `# Enhanced ADR Generation from PRD: ${prdPath}
## Advanced Prompt-Driven ADR Generation Process
This tool uses a 100% prompt-driven architecture enhanced with advanced prompting techniques:
### Enhancement Features
- **APE Optimization**: ${enhancedMode && promptOptimization ? '✅ Enabled - Prompts optimized for superior quality' : '❌ Disabled'}
- **Knowledge Generation**: ${enhancedMode && knowledgeEnhancement ? '✅ Enabled - Domain knowledge enhanced analysis' : '❌ Disabled'}
- **PRD Type Optimization**: ${prdType} - Tailored for specific domain requirements
- **Enhanced Mode**: ${enhancedMode ? '✅ Enabled - All advanced features active' : '❌ Disabled - Basic mode'}
### Enhanced AI Agent Workflow
1. **Validate PRD file existence** using secure file system operations
2. **Read PRD content** safely with proper security validation
3. **Apply domain knowledge** to enhance understanding (if enabled)
4. **Generate optimized ADRs** using APE-enhanced prompts (if enabled)
5. **Create enhanced ADR files** in the specified output directory: ${outputDirectory}
## Execution Instructions
Please execute the following enhanced comprehensive prompt:
${adrPrompt}
## Advanced Features
${
enhancedMode && knowledgeEnhancement
? `
### Knowledge Enhancement
- Domain-specific architectural knowledge has been generated
- PRD analysis is enhanced with ${prdType} domain expertise
- ADR decisions leverage domain best practices and patterns
`
: ''
}
${
enhancedMode && promptOptimization
? `
### APE Optimization
- Prompts have been automatically optimized for quality
- Enhanced evaluation criteria ensure superior ADR generation
- Optimization focused on task completion, clarity, and specificity
`
: ''
}
## Security and Validation
- All file operations include security validation
- Path traversal protection is enabled
- System directory access is prevented
- User confirmation is required for file creation
- Content validation ensures safe enhanced ADR generation
## Expected Enhanced Workflow
1. Execute file existence check for: ${prdPath}
2. If file exists, read PRD content securely
3. Apply domain knowledge to enhance PRD understanding
4. Analyze PRD content using optimized prompts
5. Generate domain-enhanced individual ADRs for each decision
6. Create file creation prompts for each enhanced ADR
7. Confirm with user before writing files to: ${outputDirectory}
The enhanced process maintains full traceability from PRD requirements to generated ADRs while providing superior quality through advanced prompting techniques and ensuring security and user control over file operations.`,
},
],
};
}
} catch (error) {
throw new McpAdrError(
`Failed to generate ADR prompts from PRD: ${error instanceof Error ? error.message : String(error)}`,
'PROMPT_GENERATION_ERROR'
);
}
}
private async compareAdrProgress(args: Record<string, unknown>): Promise<CallToolResult> {
const {
todoPath = 'TODO.md',
adrDirectory = this.config.adrDirectory,
projectPath = this.config.projectPath,
environment = 'auto-detect',
environmentConfig = {},
validationType = 'full',
includeFileChecks = true,
includeRuleValidation = true,
deepCodeAnalysis = true,
functionalValidation = true,
strictMode = true,
environmentValidation = true,
} = args;
const { getAdrDirectoryPath } = await import('./utils/config.js');
const path = await import('path');
// Resolve paths
const absoluteTodoPath = path.resolve(projectPath as string, todoPath as string);
const absoluteAdrPath = adrDirectory
? path.resolve(projectPath as string, adrDirectory as string)
: getAdrDirectoryPath(this.config);
this.logger.info(
`Comparing ADR progress: TODO(${absoluteTodoPath}) vs ADRs(${absoluteAdrPath}) vs Environment(${projectPath}) [env: ${environment}]`
);
// Environment validation and auto-detection
let detectedEnvironment = environment;
let finalEnvironmentConfig = { ...(environmentConfig as Record<string, unknown>) };
if (
environmentValidation &&
(validationType === 'full' || validationType === 'environment-only')
) {
try {
const envResult = await this.detectAndValidateEnvironment(
projectPath as string,
environment as string,
environmentConfig as Record<string, unknown>
);
detectedEnvironment = envResult.detectedEnvironment;
finalEnvironmentConfig = { ...finalEnvironmentConfig, ...envResult.environmentConfig };
this.logger.info(`Environment detection result: ${detectedEnvironment}`);
} catch (error) {
this.logger.warn(
`Environment detection failed: ${error instanceof Error ? error.message : String(error)}`
);
}
}
try {
// Step 1: Read TODO.md file directly
let todoContent = '';
if (validationType === 'full' || validationType === 'todo-only') {
try {
const fs = await import('fs/promises');
todoContent = await fs.readFile(absoluteTodoPath, 'utf-8');
} catch (error) {
this.logger.warn(
`Could not read TODO.md file: ${error instanceof Error ? error.message : String(error)}`
);
}
}
// Step 2: Use actual project structure scanning
let projectStructure = null;
if (validationType === 'full' || validationType === 'environment-only') {
try {
const { scanProjectStructure } = await import('./utils/actual-file-operations.js');
const includeContent = (deepCodeAnalysis as boolean) || (functionalValidation as boolean);
projectStructure = await scanProjectStructure(projectPath as string, {
readContent: includeContent,
maxFileSize: includeContent ? 10000 : 0,
});
} catch (error) {
this.logger.warn(
`Could not scan project structure: ${error instanceof Error ? error.message : String(error)}`
);
}
}
// Perform actual analysis locally instead of relying on AI execution
let discoveryResult: unknown = null;
if (validationType === 'full' || validationType === 'adr-only') {
const { discoverAdrsInDirectory } = await import('./utils/adr-discovery.js');
discoveryResult = await discoverAdrsInDirectory(
absoluteAdrPath as string,
true,
projectPath as string
);
}
const analysis = await this.performLocalAdrProgressAnalysis({
todoContent,
todoPath: absoluteTodoPath,
discoveredAdrs: (discoveryResult as { adrs?: unknown[] })?.adrs || [],
adrDirectory: absoluteAdrPath,
projectStructure: projectStructure || null,
projectPath: projectPath as string,
validationType: validationType as string,
includeFileChecks: includeFileChecks as boolean,
includeRuleValidation: includeRuleValidation as boolean,
deepCodeAnalysis: deepCodeAnalysis as boolean,
functionalValidation: functionalValidation as boolean,
strictMode: strictMode as boolean,
environment: detectedEnvironment as string,
environmentConfig: finalEnvironmentConfig,
environmentValidation: environmentValidation as boolean,
});
return {
content: [
{
type: 'text',
text: analysis,
},
],
};
} catch (error) {
throw new McpAdrError(
`Failed to compare ADR progress: ${error instanceof Error ? error.message : String(error)}`,
'VALIDATION_ERROR'
);
}
}
/**
* Detect and validate environment context
*/
private async detectAndValidateEnvironment(
projectPath: string,
environment: string,
environmentConfig: Record<string, unknown>
): Promise<{ detectedEnvironment: string; environmentConfig: Record<string, unknown> }> {
const path = await import('path');
const fs = await import('fs/promises');
let detectedEnvironment = environment;
let finalConfig = { ...environmentConfig };
if (environment === 'auto-detect') {
// Auto-detect environment based on project structure
try {
// Check for environment indicator files
const envFiles = [
'.env.development',
'.env.staging',
'.env.production',
'.env.test',
'package.json',
'docker-compose.yml',
'Dockerfile',
];
const existingFiles: string[] = [];
for (const file of envFiles) {
try {
await fs.access(path.join(projectPath, file));
existingFiles.push(file);
} catch {
// File doesn't exist, continue
}
}
// Environment detection logic
if (existingFiles.includes('.env.production') || existingFiles.includes('Dockerfile')) {
detectedEnvironment = 'production';
} else if (existingFiles.includes('.env.staging')) {
detectedEnvironment = 'staging';
} else if (existingFiles.includes('.env.test')) {
detectedEnvironment = 'testing';
} else {
detectedEnvironment = 'development';
}
// Set environment-specific default configurations
switch (detectedEnvironment) {
case 'production':
finalConfig = {
securityLevel: 'critical',
requiredFiles: ['package.json', 'README.md'],
requiredServices: ['monitoring', 'logging'],
performanceRequirements: { minUptime: 99.9 },
...finalConfig,
};
break;
case 'staging':
finalConfig = {
securityLevel: 'high',
requiredFiles: ['package.json'],
requiredServices: ['testing', 'monitoring'],
performanceRequirements: { minUptime: 95 },
...finalConfig,
};
break;
case 'testing':
finalConfig = {
securityLevel: 'medium',
requiredFiles: ['package.json'],
requiredServices: ['testing'],
performanceRequirements: {},
...finalConfig,
};
break;
default: // development
finalConfig = {
securityLevel: 'medium',
requiredFiles: ['package.json'],
requiredServices: [],
performanceRequirements: {},
...finalConfig,
};
}
} catch (error) {
this.logger.warn(
`Environment auto-detection failed: ${error instanceof Error ? error.message : String(error)}`
);
detectedEnvironment = 'development'; // fallback
}
}
return { detectedEnvironment, environmentConfig: finalConfig };
}
/**
* Perform local ADR progress analysis without relying on AI execution
*/
private async performLocalAdrProgressAnalysis(params: {
todoContent: string;
todoPath: string;
discoveredAdrs: unknown[];
adrDirectory: string;
projectStructure: unknown;
projectPath: string;
validationType: string;
includeFileChecks: boolean;
includeRuleValidation: boolean;
deepCodeAnalysis: boolean;
functionalValidation: boolean;
strictMode: boolean;
environment: string;
environmentConfig: unknown;
environmentValidation: boolean;
}): Promise<string> {
const {
todoContent,
todoPath,
discoveredAdrs,
adrDirectory,
projectStructure,
projectPath,
validationType,
includeFileChecks,
includeRuleValidation,
deepCodeAnalysis,
functionalValidation,
strictMode,
environment,
environmentConfig,
environmentValidation,
} = params;
const currentDate = new Date().toISOString().split('T')[0];
// Parse TODO content to extract tasks
const todoTasks = this.parseTodoTasks(todoContent);
// Basic analysis
const totalAdrs = discoveredAdrs.length;
const totalTasks = todoTasks.length;
const completedTasks = todoTasks.filter(task => task.completed).length;
// Calculate alignment score (simplified, now environment-aware)
const adrTaskMapping = this.mapTasksToAdrs(
todoTasks,
discoveredAdrs,
environment,
environmentConfig
);
const alignedTasks = adrTaskMapping.aligned.length;
let alignmentScore = totalTasks > 0 ? Math.round((alignedTasks / totalTasks) * 100) : 0;
// Environment-aware scoring adjustments
if (environmentValidation && environmentConfig) {
const envScore = this.calculateEnvironmentScore(
projectStructure,
environment,
environmentConfig
);
alignmentScore = Math.round((alignmentScore + envScore) / 2); // Blend scores
}
// File existence checks
let fileCheckResults = '';
if (includeFileChecks && projectStructure) {
fileCheckResults = this.performFileExistenceChecks(todoTasks, projectStructure);
}
// Environment compliance checks
let environmentAnalysisResults = '';
if (environmentValidation && environmentConfig) {
environmentAnalysisResults = this.performEnvironmentComplianceAnalysis(
projectStructure,
environment,
environmentConfig,
strictMode
);
}
// Mock vs Production analysis
let mockAnalysisResults = '';
if (deepCodeAnalysis && projectStructure) {
mockAnalysisResults = this.performMockVsProductionAnalysis(projectStructure, strictMode);
}
return `# ADR Progress Validation Report
**Validation Date**: ${currentDate}
**Validation Type**: ${validationType}
**Project Path**: ${projectPath}
**TODO Path**: ${todoPath}
**ADR Directory**: ${adrDirectory}
**Environment**: ${environment}${environmentValidation ? ` (validation enabled)` : ''}
## Summary
- **Total ADRs**: ${totalAdrs}
- **Total TODO Tasks**: ${totalTasks}
- **Completed Tasks**: ${completedTasks}
- **Alignment Score**: ${alignmentScore}%
- **Compliance Score**: ${Math.max(alignmentScore - 10, 0)}%
- **Environment**: ${environment}
## Configuration
- **File Checks**: ${includeFileChecks ? 'Enabled' : 'Disabled'}
- **Rule Validation**: ${includeRuleValidation ? 'Enabled' : 'Disabled'}
- **Deep Code Analysis**: ${deepCodeAnalysis ? 'Enabled' : 'Disabled'}
- **Functional Validation**: ${functionalValidation ? 'Enabled' : 'Disabled'}
- **Strict Mode**: ${strictMode ? 'Enabled - High scrutiny for mock vs production' : 'Disabled'}
- **Environment Validation**: ${environmentValidation ? 'Enabled' : 'Disabled'}
## Environment Context
- **Target Environment**: ${environment}
- **Security Level**: ${(environmentConfig as Record<string, unknown>)?.['securityLevel'] || 'Not specified'}
- **Required Files**: ${((environmentConfig as Record<string, unknown>)?.['requiredFiles'] as unknown[] | undefined)?.length || 0} files
- **Required Services**: ${((environmentConfig as Record<string, unknown>)?.['requiredServices'] as unknown[] | undefined)?.length || 0} services
## ADR Discovery Results
${
totalAdrs > 0
? `Found ${totalAdrs} ADRs:\n${discoveredAdrs
.map((adr, i) => {
const adrRecord = adr as Record<string, unknown>;
return `${i + 1}. **${adrRecord['title']}** (${adrRecord['status']}) - ${adrRecord['filename']}`;
})
.join('\n')}`
: 'No ADRs found in the specified directory.'
}
## TODO Task Analysis
${
totalTasks > 0
? `Found ${totalTasks} tasks:\n${todoTasks
.map((task, i) => `${i + 1}. ${task.completed ? '✅' : '⏳'} ${task.title}`)
.join('\n')}`
: 'No tasks found in TODO.md file.'
}
## Alignment Analysis
### ✅ Properly Aligned Tasks
${
adrTaskMapping.aligned.length > 0
? adrTaskMapping.aligned
.map(task => `- ${task.title}: Corresponds to ADR requirements`)
.join('\n')
: '- No aligned tasks identified'
}
### ⚠️ Misaligned Tasks
${
adrTaskMapping.misaligned.length > 0
? adrTaskMapping.misaligned
.map(task => `- ${task.title}: May not fully align with ADR specifications`)
.join('\n')
: '- No misaligned tasks identified'
}
### ❌ Missing Tasks
${
adrTaskMapping.missing.length > 0
? adrTaskMapping.missing.map(gap => `- ${gap}: Required by ADRs but not in TODO`).join('\n')
: '- No obvious missing tasks identified'
}
## Implementation Status
${fileCheckResults || '### File Existence Validation\n- File checks disabled or no project structure available'}
${environmentAnalysisResults || ''}
${mockAnalysisResults || ''}
## Recommendations
### High Priority Actions
${
alignmentScore < 70
? '1. **Improve ADR-TODO Alignment**: Review TODO tasks against ADR requirements\n2. **Add Missing Tasks**: Identify and add tasks required by ADRs'
: '1. **Maintain Current Alignment**: Continue following ADR specifications'
}
${
completedTasks < totalTasks * 0.5
? '\n3. **Accelerate Implementation**: Focus on completing pending tasks'
: ''
}
${
environmentValidation && environment === 'production' && alignmentScore < 90
? '\n4. **⚠️ Production Environment Warning**: Current alignment may not meet production requirements'
: ''
}
### Medium Priority Actions
1. **Review Implementation Quality**: ${strictMode ? 'Strict mode analysis above shows' : 'Consider enabling strict mode for'} detailed quality assessment
2. **Update Documentation**: Ensure TODO.md reflects current project state
${
environmentValidation
? `3. **Environment Compliance**: Ensure ${environment} environment requirements are met`
: ''
}
### Low Priority Actions
1. **Optimize Workflow**: Consider tools for automated ADR-TODO synchronization
2. **Regular Validation**: Schedule periodic ADR progress reviews
## Next Steps
1. Address high-priority alignment issues identified above
2. ${totalTasks === 0 ? 'Create initial TODO.md from ADR requirements' : 'Update TODO.md with missing tasks'}
3. ${includeFileChecks ? 'Verify implementation of completed tasks' : 'Enable file checks for detailed implementation verification'}
4. ${includeRuleValidation ? 'Resolve architectural rule compliance violations' : 'Enable rule validation for compliance checking'}
\`\`\`
To re-run this validation with strict mode:
\`\`\`json
{
"tool": "compare_adr_progress",
"args": {
"todoPath": "${todoPath}",
"adrDirectory": "${adrDirectory}",
"validationType": "full",
"deepCodeAnalysis": true,
"functionalValidation": true,
"strictMode": true
}
}
\`\`\`
`;
}
/**
* Parse TODO.md content to extract tasks
*/
private parseTodoTasks(
todoContent: string
): Array<{ title: string; completed: boolean; description?: string }> {
if (!todoContent) return [];
const lines = todoContent.split('\n');
const tasks: Array<{ title: string; completed: boolean; description?: string }> = [];
for (const line of lines) {
// Look for markdown checkbox patterns
const taskMatch = line.match(/^\s*[-*]\s*\[([x\s])\]\s*(.+)$/i);
if (taskMatch && taskMatch[1] && taskMatch[2]) {
const checkbox = taskMatch[1];
const title = taskMatch[2];
tasks.push({
title: title.trim(),
completed: checkbox.toLowerCase() === 'x',
});
}
// Also look for simple list items that might be tasks
else if (line.match(/^\s*[-*]\s+\w+/)) {
const title = line.replace(/^\s*[-*]\s+/, '').trim();
if (title.length > 3) {
// Avoid very short items
tasks.push({
title,
completed: false,
});
}
}
}
return tasks;
}
/**
* Map TODO tasks to ADRs to identify alignment (now environment-aware)
*/
private mapTasksToAdrs(
tasks: Array<{ title: string; completed: boolean }>,
adrs: unknown[],
environment?: string,
environmentConfig?: unknown
): {
aligned: typeof tasks;
misaligned: typeof tasks;
missing: string[];
} {
const aligned: typeof tasks = [];
const misaligned: typeof tasks = [];
const missing: string[] = [];
// Simple keyword matching for alignment detection
const adrKeywords = adrs.flatMap(adr => {
const adrRecord = adr as Record<string, unknown>;
return [
String(adrRecord['title'] || '').toLowerCase(),
...String(adrRecord['decision'] || '')
.toLowerCase()
.split(/\s+/)
.filter((w: string) => w.length > 4),
...String(adrRecord['context'] || '')
.toLowerCase()
.split(/\s+/)
.filter((w: string) => w.length > 4),
];
});
// Environment-specific keywords that should be prioritized
const envKeywords: string[] = [];
if (environment && environmentConfig) {
if (environment === 'production') {
envKeywords.push('deploy', 'production', 'monitoring', 'security', 'performance');
} else if (environment === 'staging') {
envKeywords.push('test', 'staging', 'integration', 'validation');
} else if (environment === 'development') {
envKeywords.push('setup', 'development', 'local', 'debug');
}
}
for (const task of tasks) {
const taskLower = task.title.toLowerCase();
const firstWord = taskLower.split(' ')[0] || '';
const hasKeywordMatch = adrKeywords.some(
keyword => taskLower.includes(keyword) || keyword.includes(firstWord)
);
// Environment-aware alignment scoring
const hasEnvKeywordMatch = envKeywords.some(keyword => taskLower.includes(keyword));
if (hasKeywordMatch || hasEnvKeywordMatch) {
aligned.push(task);
} else {
misaligned.push(task);
}
}
// Identify potential missing tasks based on ADR content
for (const adr of adrs) {
const adrRecord = adr as Record<string, unknown>;
if (adrRecord['status'] === 'accepted' && adrRecord['decision']) {
const decisionWords = String(adrRecord['decision']).toLowerCase().split(/\s+/);
const implementationWords = [
'implement',
'create',
'build',
'develop',
'add',
'setup',
'configure',
];
if (implementationWords.some(word => decisionWords.includes(word))) {
const adrTitle = String(adrRecord['title'] || '');
const adrFirstWord = adrTitle.toLowerCase().split(' ')[0] || '';
const hasCorrespondingTask = tasks.some(task =>
task.title.toLowerCase().includes(adrFirstWord)
);
if (!hasCorrespondingTask) {
missing.push(`Implement ${adrTitle}`);
}
}
}
}
// Environment-specific missing tasks
if (environment && environmentConfig) {
const envConfig = environmentConfig as Record<string, unknown>;
if (envConfig['requiredFiles']) {
for (const file of envConfig['requiredFiles'] as string[]) {
const hasFileTask = tasks.some(task =>
task.title.toLowerCase().includes(file.toLowerCase())
);
if (!hasFileTask) {
missing.push(`Create ${file} for ${environment} environment`);
}
}
}
if (envConfig['requiredServices']) {
for (const service of envConfig['requiredServices'] as string[]) {
const hasServiceTask = tasks.some(task =>
task.title.toLowerCase().includes(service.toLowerCase())
);
if (!hasServiceTask) {
missing.push(`Setup ${service} service for ${environment}`);
}
}
}
}
return { aligned, misaligned, missing };
}
/**
* Check file existence for completed tasks
*/
private performFileExistenceChecks(
tasks: Array<{ title: string; completed: boolean }>,
projectStructure: any
): string {
if (!projectStructure) return '- Project structure not available';
const allFiles = [
...(projectStructure.packageFiles || []),
...(projectStructure.configFiles || []),
...(projectStructure.buildFiles || []),
...(projectStructure.dockerFiles || []),
...(projectStructure.ciFiles || []),
...(projectStructure.scriptFiles || []),
];
let results = '### File Existence Validation\n';
let checkCount = 0;
for (const task of tasks) {
if (task.completed) {
// Simple heuristic: look for files mentioned in task title
const taskLower = task.title.toLowerCase();
const mentionedFiles = allFiles.filter(
file =>
taskLower.includes(file.filename.toLowerCase()) ||
taskLower.includes(file.filename.replace(/\.[^.]+$/, '').toLowerCase())
);
if (mentionedFiles.length > 0) {
results += `- ✅ **${task.title}**: Found related files (${mentionedFiles.map(f => f.filename).join(', ')})\n`;
checkCount++;
} else if (
taskLower.includes('file') ||
taskLower.includes('create') ||
taskLower.includes('implement')
) {
results += `- ⚠️ **${task.title}**: No clearly related files found\n`;
checkCount++;
}
}
}
if (checkCount === 0) {
results += '- No file-related completed tasks to validate\n';
}
return results;
}
/**
* Analyze code for mock vs production implementation
*/
private performMockVsProductionAnalysis(projectStructure: any, strictMode: boolean): string {
if (!projectStructure) return '';
const codeFiles = [
...(projectStructure.buildFiles || []),
...(projectStructure.configFiles || []),
].filter(file => file.content && file.content !== '[Binary or unreadable file]');
if (codeFiles.length === 0) return '';
let results = '\n### Mock vs Production Code Analysis\n';
let mockIndicators = 0;
let productionIndicators = 0;
const mockPatterns = [
/TODO:/gi,
/FIXME:/gi,
/NotImplementedException/gi,
/throw.*not.*implement/gi,
/return.*mock/gi,
/placeholder/gi,
/stub/gi,
/return\s+null;/gi,
/return\s+""/gi,
/return\s+\[\]/gi,
/return\s+{}/gi,
];
const productionPatterns = [
/error\s+handling/gi,
/try\s*{/gi,
/catch\s*\(/gi,
/validate/gi,
/authentication/gi,
/authorization/gi,
/database/gi,
/api/gi,
/config/gi,
];
for (const file of codeFiles.slice(0, 10)) {
// Limit analysis to prevent overwhelming output
const content = file.content;
const fileMockCount = mockPatterns.reduce(
(count, pattern) => count + (content.match(pattern) || []).length,
0
);
const fileProdCount = productionPatterns.reduce(
(count, pattern) => count + (content.match(pattern) || []).length,
0
);
mockIndicators += fileMockCount;
productionIndicators += fileProdCount;
if (fileMockCount > 0 || fileProdCount > 2) {
const status =
fileMockCount > fileProdCount
? '❌ **Mock/Stub**'
: fileProdCount > fileMockCount * 2
? '✅ **Production Ready**'
: '⚠️ **Partial Implementation**';
results += `- ${status}: ${file.filename} `;
if (fileMockCount > 0) {
results += `(${fileMockCount} mock indicators) `;
}
if (fileProdCount > 0) {
results += `(${fileProdCount} production indicators)`;
}
results += '\n';
}
}
results += `\n#### Overall Code Quality Assessment\n`;
results += `- **Mock Indicators Found**: ${mockIndicators} instances\n`;
results += `- **Production Indicators Found**: ${productionIndicators} instances\n`;
if (strictMode) {
const qualityScore =
productionIndicators > mockIndicators * 2
? 'Good'
: productionIndicators > mockIndicators
? 'Fair'
: 'Needs Improvement';
results += `- **Quality Assessment**: ${qualityScore}\n`;
if (mockIndicators > 0) {
results += `- **⚠️ Strict Mode Warning**: Found ${mockIndicators} potential mock/stub indicators\n`;
}
}
return results;
}
/**
* Calculate environment-specific compliance score
*/
private calculateEnvironmentScore(
projectStructure: any,
environment: string,
environmentConfig: any
): number {
if (!projectStructure || !environmentConfig) return 0;
let score = 100; // Start with perfect score
// Check required files
if (environmentConfig.requiredFiles) {
const allFiles = [
...(projectStructure.packageFiles || []),
...(projectStructure.configFiles || []),
...(projectStructure.buildFiles || []),
...(projectStructure.dockerFiles || []),
...(projectStructure.ciFiles || []),
...(projectStructure.scriptFiles || []),
];
const existingFiles = allFiles.map(f => f.filename);
const missingFiles = environmentConfig.requiredFiles.filter(
(file: string) => !existingFiles.includes(file)
);
// Deduct 10 points per missing required file
score -= missingFiles.length * 10;
}
// Environment-specific penalties
if (environment === 'production') {
// Production requires higher standards
if (!projectStructure.dockerFiles?.length) score -= 15;
if (!projectStructure.ciFiles?.length) score -= 10;
}
return Math.max(score, 0);
}
/**
* Perform environment compliance analysis
*/
private performEnvironmentComplianceAnalysis(
projectStructure: any,
environment: string,
environmentConfig: any,
strictMode: boolean
): string {
if (!projectStructure || !environmentConfig) {
return '\n### Environment Compliance Analysis\n- Environment analysis disabled or no project structure available\n';
}
let results = '\n### Environment Compliance Analysis\n';
// Required files analysis
if (environmentConfig.requiredFiles) {
results += `#### Required Files for ${environment} Environment\n`;
const allFiles = [
...(projectStructure.packageFiles || []),
...(projectStructure.configFiles || []),
...(projectStructure.buildFiles || []),
...(projectStructure.dockerFiles || []),
...(projectStructure.ciFiles || []),
...(projectStructure.scriptFiles || []),
];
const existingFiles = allFiles.map(f => f.filename);
for (const requiredFile of environmentConfig.requiredFiles) {
const exists = existingFiles.includes(requiredFile);
results += `- ${exists ? '✅' : '❌'} **${requiredFile}**: ${exists ? 'Found' : 'Missing'}\n`;
}
}
// Security level compliance
if (environmentConfig.securityLevel) {
results += `\n#### Security Level: ${environmentConfig.securityLevel}\n`;
const securityIndicators = this.analyzeSecurityCompliance(
projectStructure,
environmentConfig.securityLevel
);
results += securityIndicators;
}
// Environment-specific recommendations
results += `\n#### ${environment} Environment Recommendations\n`;
switch (environment) {
case 'production':
results +=
'- ⚠️ **Production Critical**: Ensure monitoring, logging, and backup strategies are implemented\n';
results += '- 🔒 **Security**: Implement comprehensive security measures\n';
results += '- 📊 **Performance**: Monitor and optimize for production workloads\n';
if (strictMode) {
results +=
'- 🔍 **Strict Mode**: Enhanced validation enabled for production environment\n';
}
break;
case 'staging':
results += '- 🧪 **Testing**: Ensure comprehensive test coverage and validation\n';
results += '- 📋 **Validation**: Implement environment parity checks\n';
break;
case 'development':
results += '- 🛠️ **Development**: Focus on developer experience and debugging tools\n';
results += '- 🔄 **Iteration**: Ensure fast feedback loops\n';
break;
}
return results;
}
/**
* Analyze security compliance based on security level
*/
private analyzeSecurityCompliance(projectStructure: any, securityLevel: string): string {
let results = '';
const securityFiles = [
...(projectStructure.configFiles || []),
...(projectStructure.dockerFiles || []),
].filter(
file =>
file.filename.includes('security') ||
file.filename.includes('auth') ||
file.filename.includes('.env') ||
file.filename === 'Dockerfile'
);
const hasSecurityConfig = securityFiles.length > 0;
switch (securityLevel) {
case 'critical':
results += `- ${hasSecurityConfig ? '✅' : '❌'} **Critical Security**: ${hasSecurityConfig ? 'Security configuration found' : 'No security configuration detected'}\n`;
if (!hasSecurityConfig) {
results += ' - **Action Required**: Implement comprehensive security measures\n';
}
break;
case 'high':
results += `- ${hasSecurityConfig ? '✅' : '⚠️'} **High Security**: ${hasSecurityConfig ? 'Some security configuration found' : 'Limited security configuration'}\n`;
break;
case 'medium':
results += `- ℹ️ **Medium Security**: Basic security measures recommended\n`;
break;
default:
results += `- ℹ️ **Security Level**: ${securityLevel} (consider increasing for production)\n`;
}
return results;
}
/**
* Content masking tool implementations
*/
private async analyzeContentSecurity(args: AnalyzeContentSecurityArgs): Promise<CallToolResult> {
const { analyzeContentSecurity } = await import('./tools/content-masking-tool.js');
return await analyzeContentSecurity(args);
}
private async generateContentMasking(args: GenerateContentMaskingArgs): Promise<CallToolResult> {
const { generateContentMasking } = await import('./tools/content-masking-tool.js');
return await generateContentMasking(args);
}
private async configureCustomPatterns(
args: ConfigureCustomPatternsArgs
): Promise<CallToolResult> {
const { configureCustomPatterns } = await import('./tools/content-masking-tool.js');
return await configureCustomPatterns(args);
}
private async applyBasicContentMasking(
args: ApplyBasicContentMaskingArgs
): Promise<CallToolResult> {
const { applyBasicContentMasking } = await import('./tools/content-masking-tool.js');
return await applyBasicContentMasking(args);
}
private async validateContentMasking(args: ValidateContentMaskingArgs): Promise<CallToolResult> {
const { validateContentMasking } = await import('./tools/content-masking-tool.js');
return await validateContentMasking(args);
}
private async manageCache(args: Record<string, unknown>): Promise<CallToolResult> {
const { action, key } = args;
try {
const { clearCache, getCacheStats, cleanupCache, invalidateCache } = await import(
'./utils/cache.js'
);
switch (action) {
case 'clear': {
const clearPrompt = await clearCache();
return {
content: [
{
type: 'text',
text: `# Cache Clear Operation
## AI Delegation Required
Please execute the following cache clearing operation:
${clearPrompt.prompt}
## Implementation Instructions
${clearPrompt.instructions}
## Expected Result
After successful execution, all cache entries will be removed while preserving the cache directory structure and metadata.json file.`,
},
],
};
}
case 'stats': {
const statsPrompt = await getCacheStats();
return {
content: [
{
type: 'text',
text: `# Cache Statistics Collection
## AI Delegation Required
Please execute the following cache statistics collection operation:
${statsPrompt.prompt}
## Implementation Instructions
${statsPrompt.instructions}
## Expected Information
The AI agent will provide:
- **Total Entries**: Number of cache files
- **Total Size**: Combined size of all cache files
- **Oldest Entry**: Cache key of the oldest entry
- **Newest Entry**: Cache key of the newest entry
## Cache Directory
\`.mcp-adr-cache/\`
## Cache Types
- **Knowledge Graph**: Architectural analysis results (TTL: 1 hour)
- **Analysis Report**: Project analysis reports (TTL: 30 minutes)
- **ADR List**: ADR inventory and metadata (TTL: 15 minutes)
## Management
Use \`manage_cache\` tool with different actions:
- \`clear\`: Remove all cache entries
- \`cleanup\`: Remove expired entries only
- \`invalidate\`: Remove specific cache entry`,
},
],
};
}
case 'cleanup': {
const cleanupPrompt = await cleanupCache();
return {
content: [
{
type: 'text',
text: `# Cache Cleanup Operation
## AI Delegation Required
Please execute the following cache cleanup operation:
${cleanupPrompt.prompt}
## Implementation Instructions
${cleanupPrompt.instructions}
## Expected Result
The AI agent will remove expired cache entries and provide a count of cleaned files.`,
},
],
};
}
case 'invalidate': {
if (!key) {
throw new McpAdrError('Cache key is required for invalidate action', 'INVALID_INPUT');
}
const invalidatePrompt = await invalidateCache(key as string);
return {
content: [
{
type: 'text',
text: `# Cache Invalidation Operation
## AI Delegation Required
Please execute the following cache invalidation operation:
${invalidatePrompt.prompt}
## Implementation Instructions
${invalidatePrompt.instructions}
## Target Cache Entry
**Cache Key**: ${key}
The AI agent will safely remove the specified cache entry.`,
},
],
};
}
default:
throw new McpAdrError(`Unknown cache action: ${action}`, 'INVALID_INPUT');
}
} catch (error) {
throw new McpAdrError(
`Cache management failed: ${error instanceof Error ? error.message : String(error)}`,
'CACHE_ERROR'
);
}
}
private async configureOutputMasking(args: Record<string, unknown>): Promise<CallToolResult> {
const { action = 'get', enabled, strategy, customPatterns } = args;
try {
const { validateMaskingConfig } = await import('./utils/output-masking.js');
switch (action) {
case 'get': {
return {
content: [
{
type: 'text',
text: `# Current Output Masking Configuration
## Settings
- **Enabled**: ${this.maskingConfig.enabled}
- **Strategy**: ${this.maskingConfig.strategy}
- **Custom Patterns**: ${this.maskingConfig.customPatterns?.length || 0} patterns
- **Skip Patterns**: ${this.maskingConfig.skipPatterns?.length || 0} patterns
## Available Strategies
- **full**: Replace entire sensitive content with [REDACTED]
- **partial**: Show safe prefix/suffix, mask middle (e.g., sk-...****)
- **placeholder**: Replace with descriptive placeholders (e.g., <YOUR_API_KEY>)
- **environment**: Replace with environment variable references (e.g., \${API_KEY})
## Configuration
Use \`configure_output_masking\` tool with:
- \`action: "set"\` to update configuration
- \`action: "reset"\` to restore defaults
## Current Status
${this.maskingConfig.enabled ? '✅ Output masking is ACTIVE' : '⚠️ Output masking is DISABLED'}
`,
},
],
};
}
case 'set': {
const newConfig = { ...this.maskingConfig };
if (typeof enabled === 'boolean') {
newConfig.enabled = enabled;
}
if (
strategy &&
['full', 'partial', 'placeholder', 'environment'].includes(strategy as string)
) {
newConfig.strategy = strategy as 'full' | 'partial' | 'placeholder' | 'environment';
}
if (Array.isArray(customPatterns)) {
newConfig.customPatterns = customPatterns;
}
const validation = validateMaskingConfig(newConfig);
if (!validation.isValid) {
throw new McpAdrError(
`Invalid masking configuration: ${validation.errors.join(', ')}`,
'INVALID_CONFIG'
);
}
this.maskingConfig = newConfig;
return {
content: [
{
type: 'text',
text: `✅ Output masking configuration updated successfully!
## New Settings
- **Enabled**: ${newConfig.enabled}
- **Strategy**: ${newConfig.strategy}
- **Custom Patterns**: ${newConfig.customPatterns?.length || 0} patterns
${
newConfig.enabled
? '🔒 All MCP tool and resource outputs will now be masked according to the new configuration.'
: '⚠️ Output masking is disabled. Sensitive information may be exposed in responses.'
}
`,
},
],
};
}
case 'reset': {
const { createMaskingConfig } = await import('./utils/output-masking.js');
this.maskingConfig = createMaskingConfig();
return {
content: [
{
type: 'text',
text: `✅ Output masking configuration reset to defaults!
## Default Settings
- **Enabled**: ${this.maskingConfig.enabled}
- **Strategy**: ${this.maskingConfig.strategy}
- **Custom Patterns**: ${this.maskingConfig.customPatterns?.length || 0} patterns
- **Skip Patterns**: ${this.maskingConfig.skipPatterns?.length || 0} patterns
🔒 Default masking is now active for all outputs.
`,
},
],
};
}
default:
throw new McpAdrError(`Unknown masking action: ${action}`, 'INVALID_INPUT');
}
} catch (error) {
throw new McpAdrError(
`Output masking configuration failed: ${error instanceof Error ? error.message : String(error)}`,
'CONFIG_ERROR'
);
}
}
/**
* Helper method to get domains based on PRD type
*/
private getPrdTypeDomains(prdType: string): string[] {
const domainMap: Record<string, string[]> = {
'web-application': ['api-design', 'frontend-architecture', 'database-design', 'security'],
'mobile-app': ['mobile-architecture', 'api-design', 'performance-optimization', 'security'],
microservices: ['microservices', 'api-design', 'distributed-systems', 'database-design'],
'data-platform': [
'database-design',
'data-architecture',
'performance-optimization',
'scalability',
],
'api-service': ['api-design', 'microservices', 'security', 'performance-optimization'],
general: ['api-design', 'database-design', 'security'],
};
return (
domainMap[prdType] || domainMap['general'] || ['api-design', 'database-design', 'security']
);
}
/**
* Helper method to get domains for ecosystem analysis based on technology focus
*/
private getEcosystemAnalysisDomains(technologyFocus: string[]): string[] {
// Base domains for ecosystem analysis
const baseDomains = ['api-design', 'database-design', 'security', 'performance-optimization'];
// Technology-specific domain mapping
const technologyDomainMap: Record<string, string[]> = {
react: ['frontend-architecture', 'web-applications'],
vue: ['frontend-architecture', 'web-applications'],
angular: ['frontend-architecture', 'web-applications'],
node: ['api-design', 'microservices'],
express: ['api-design', 'web-applications'],
fastify: ['api-design', 'performance-optimization'],
nestjs: ['api-design', 'microservices'],
spring: ['api-design', 'microservices'],
django: ['api-design', 'web-applications'],
flask: ['api-design', 'web-applications'],
rails: ['api-design', 'web-applications'],
laravel: ['api-design', 'web-applications'],
docker: ['containerization', 'microservices'],
kubernetes: ['containerization', 'distributed-systems'],
mongodb: ['database-design', 'data-architecture'],
postgresql: ['database-design', 'data-architecture'],
mysql: ['database-design', 'data-architecture'],
redis: ['database-design', 'performance-optimization'],
elasticsearch: ['database-design', 'data-architecture'],
kafka: ['distributed-systems', 'data-architecture'],
rabbitmq: ['distributed-systems', 'microservices'],
aws: ['cloud-architecture', 'scalability'],
azure: ['cloud-architecture', 'scalability'],
gcp: ['cloud-architecture', 'scalability'],
terraform: ['infrastructure-as-code', 'cloud-architecture'],
ansible: ['infrastructure-as-code', 'automation'],
jenkins: ['ci-cd', 'automation'],
'github-actions': ['ci-cd', 'automation'],
'gitlab-ci': ['ci-cd', 'automation'],
};
// Collect domains based on technology focus
const technologyDomains = new Set<string>();
for (const tech of technologyFocus) {
const techLower = tech.toLowerCase();
const domains = technologyDomainMap[techLower];
if (domains) {
domains.forEach(domain => technologyDomains.add(domain));
}
}
// Combine base domains with technology-specific domains
const allDomains = [...baseDomains, ...Array.from(technologyDomains)];
// Remove duplicates and limit to reasonable number
const uniqueDomains = [...new Set(allDomains)];
// Return up to 6 most relevant domains
return uniqueDomains.slice(0, 6);
}
/**
* Helper method to create base ADR generation prompt
*/
private createBaseAdrPrompt(
prdPath: string,
outputDirectory: string,
knowledgeContext: string
): string {
return `
# Enhanced ADR Generation from PRD Request
This is a comprehensive prompt-driven ADR generation process enhanced with domain knowledge and optimized prompting.
${knowledgeContext}
## Step 1: File Validation
Please verify that the PRD file exists at: ${prdPath}
## Step 2: PRD Content Reading
Read and analyze the PRD content from: ${prdPath}
## Step 3: Enhanced ADR Generation and Creation
Once you have successfully read the PRD content, analyze it using the domain knowledge above and generate Architectural Decision Records (ADRs).
### Enhanced Analysis Requirements
1. **Extract Key Decisions**: Identify all architectural decisions implied or stated in the PRD
2. **Apply Domain Knowledge**: Use the generated domain knowledge to enhance decision analysis
3. **Decision Categorization**: Group decisions by:
- Technology stack choices (informed by domain best practices)
- Architectural patterns (leveraging domain-specific patterns)
- Infrastructure decisions (considering domain requirements)
- Security considerations (applying domain security knowledge)
- Performance requirements (using domain performance insights)
- Integration approaches (following domain integration patterns)
### Enhanced ADR Generation Requirements
1. **Follow ADR Format**: Use standard ADR template with domain-enhanced content
2. **Number Sequentially**: Use format 001-decision-title.md, 002-next-decision.md, etc.
3. **Output Directory**: Place ADRs in ${outputDirectory}/
4. **Domain Context**: Include relevant domain knowledge in each ADR
5. **File Creation**: Generate file creation prompts for each ADR
### Enhanced ADR Template Format
\`\`\`markdown
# [Number]. [Title]
**Status**: [Proposed/Accepted/Deprecated/Superseded]
**Date**: [YYYY-MM-DD]
**Domain**: [Relevant domain from knowledge enhancement]
## Context
[Describe the context and problem statement from PRD, enhanced with domain knowledge]
## Decision
[Describe the architectural decision, informed by domain best practices]
## Consequences
[Describe positive and negative consequences, considering domain-specific implications]
## Domain Considerations
[Specific considerations from the domain knowledge that influenced this decision]
## Implementation Plan
[Steps to implement this decision, leveraging domain expertise]
## Related PRD Sections
[Reference specific sections from the PRD that led to this decision]
## Domain References
[References to domain knowledge that informed this decision]
\`\`\`
### Expected Enhanced Output
Please provide:
1. **File Validation Results**: Confirmation that PRD file exists and is readable
2. **PRD Content Summary**: Brief summary enhanced with domain context
3. **Domain Analysis**: How domain knowledge applies to this PRD
4. **Identified Decisions**: List of all architectural decisions with domain context
5. **Generated ADRs**: Complete enhanced ADR content for each decision
6. **File Creation Plan**: File names, directory structure, and creation order
7. **Implementation Priority**: Recommended order considering domain best practices
### Quality Assurance with Domain Enhancement
- Ensure each ADR leverages relevant domain knowledge
- Verify decisions align with domain best practices
- Check that domain considerations are properly documented
- Validate that ADR content is enhanced beyond basic analysis
`;
}
/**
* ADR suggestion tool implementations
*/
private async suggestAdrs(args: Record<string, unknown>): Promise<CallToolResult> {
const { suggestAdrs } = await import('./tools/adr-suggestion-tool.js');
return await suggestAdrs(args);
}
private async generateAdrFromDecision(
args: GenerateAdrFromDecisionArgs
): Promise<CallToolResult> {
const { generateAdrFromDecision } = await import('./tools/adr-suggestion-tool.js');
return await generateAdrFromDecision(args);
}
private async generateAdrBootstrap(args: Record<string, unknown>): Promise<CallToolResult> {
const { default: generateAdrBootstrapScripts } = await import(
'./tools/adr-bootstrap-validation-tool.js'
);
return await generateAdrBootstrapScripts(args);
}
private async bootstrapValidationLoop(args: Record<string, unknown>): Promise<CallToolResult> {
const { default: bootstrapValidationLoop } = await import(
'./tools/bootstrap-validation-loop-tool.js'
);
return await bootstrapValidationLoop(args);
}
private async discoverExistingAdrs(
args: Record<string, unknown>,
context?: ToolContext
): Promise<CallToolResult> {
const ctx = context || createNoOpContext();
try {
ctx.info('🔍 Starting ADR discovery process...');
ctx.report_progress(0, 100);
ctx.info('📂 Phase 1: Scanning ADR directory');
ctx.report_progress(30, 100);
const { discoverExistingAdrs } = await import('./tools/adr-suggestion-tool.js');
ctx.info('📄 Phase 2: Analyzing ADR files');
ctx.report_progress(60, 100);
const result = await discoverExistingAdrs(args);
ctx.info('✅ ADR discovery completed successfully');
ctx.report_progress(100, 100);
return result;
} catch (error) {
ctx.error?.(
`❌ ADR discovery failed: ${error instanceof Error ? error.message : String(error)}`
);
throw error;
}
}
private async reviewExistingAdrs(args: Record<string, unknown>): Promise<CallToolResult> {
const { reviewExistingAdrs } = await import('./tools/review-existing-adrs-tool.js');
return await reviewExistingAdrs(args);
}
/**
* ADR validation tool implementations
*/
private async validateAdr(args: Record<string, unknown>): Promise<CallToolResult> {
const { validateAdr } = await import('./tools/adr-validation-tool.js');
return await validateAdr(args as any);
}
private async validateAllAdrs(args: Record<string, unknown>): Promise<CallToolResult> {
const { validateAllAdrs } = await import('./tools/adr-validation-tool.js');
return await validateAllAdrs(args as any);
}
/**
* Research integration tool implementations
*/
private async incorporateResearch(args: Record<string, unknown>): Promise<CallToolResult> {
const { incorporateResearch } = await import('./tools/research-integration-tool.js');
return await incorporateResearch(args);
}
private async createResearchTemplate(args: Record<string, unknown>): Promise<CallToolResult> {
const { createResearchTemplate } = await import('./tools/research-integration-tool.js');
return await createResearchTemplate(args);
}
private async requestActionConfirmation(args: Record<string, unknown>): Promise<CallToolResult> {
const { requestActionConfirmation } = await import('./tools/research-integration-tool.js');
return await requestActionConfirmation(args as unknown as ActionArgs);
}
/**
* Rule generation and validation tool implementations
*/
private async generateRules(args: Record<string, unknown>): Promise<CallToolResult> {
const { generateRules } = await import('./tools/rule-generation-tool.js');
return await generateRules(args);
}
private async validateRules(args: ValidateRulesArgs): Promise<CallToolResult> {
const { validateRules } = await import('./tools/rule-generation-tool.js');
return await validateRules(args);
}
private async createRuleSet(args: CreateRuleSetArgs): Promise<CallToolResult> {
const { createRuleSet } = await import('./tools/rule-generation-tool.js');
return await createRuleSet(args);
}
/**
* Environment analysis tool implementation
*/
private async analyzeEnvironment(args: Record<string, unknown>): Promise<CallToolResult> {
const { analyzeEnvironment } = await import('./tools/environment-analysis-tool.js');
return await analyzeEnvironment(args);
}
/**
* Research question generation tool implementation
*/
private async generateResearchQuestions(args: Record<string, unknown>): Promise<CallToolResult> {
const { generateResearchQuestions } = await import('./tools/research-question-tool.js');
return await generateResearchQuestions(args);
}
/**
* Perform research tool implementation
*/
private async performResearch(
args: Record<string, unknown>,
context?: ToolContext
): Promise<CallToolResult> {
const ctx = context || createNoOpContext();
if (!('question' in args) || typeof args['question'] !== 'string') {
throw new McpAdrError('Missing required parameter: question', 'INVALID_ARGUMENTS');
}
try {
ctx.info('🔍 Starting research process...');
ctx.report_progress(0, 100);
ctx.info('📊 Phase 1: Initializing research framework');
ctx.report_progress(10, 100);
const { performResearch } = await import('./tools/perform-research-tool.js');
ctx.info('📚 Phase 2: Executing research orchestration');
ctx.report_progress(20, 100);
const result = await performResearch(
args as {
question: string;
projectPath?: string;
adrDirectory?: string;
confidenceThreshold?: number;
performWebSearch?: boolean;
},
ctx // ✅ Pass context to tool function for progress updates
);
return result;
} catch (error) {
ctx.error?.(
`❌ Research execution failed: ${error instanceof Error ? error.message : String(error)}`
);
throw new McpAdrError(
`Failed to perform research: ${error instanceof Error ? error.message : String(error)}`,
'RESEARCH_EXECUTION_ERROR'
);
}
}
/**
* LLM web search tool implementation
*/
private async llmWebSearch(
args: Record<string, unknown>,
context?: ToolContext
): Promise<CallToolResult> {
const ctx = context || createNoOpContext();
if (!('query' in args) || typeof args['query'] !== 'string') {
throw new McpAdrError('Missing required parameter: query', 'INVALID_ARGUMENTS');
}
ctx.info('🌐 Starting LLM-managed web search...');
ctx.report_progress(0, 100);
const { llmWebSearch } = await import('./tools/llm-web-search-tool.js');
return await llmWebSearch(
args as {
query: string;
maxResults?: number;
includeContent?: boolean;
llmInstructions?: string;
projectPath?: string;
adrDirectory?: string;
},
ctx // ✅ Pass context to tool function for progress updates
);
}
/**
* LLM cloud management tool implementation
*/
private async llmCloudManagement(
args: Record<string, unknown>,
context?: ToolContext
): Promise<CallToolResult> {
const ctx = context || createNoOpContext();
if (!('provider' in args) || !('action' in args) || !('llmInstructions' in args)) {
throw new McpAdrError(
'Missing required parameters: provider, action, llmInstructions',
'INVALID_ARGUMENTS'
);
}
ctx.info('🔧 Starting LLM-managed cloud operation...');
ctx.report_progress(0, 100);
const { llmCloudManagement } = await import('./tools/llm-cloud-management-tool.js');
return await llmCloudManagement(
args as {
provider: 'aws' | 'azure' | 'gcp' | 'redhat' | 'ubuntu' | 'macos';
action: string;
parameters?: Record<string, any>;
llmInstructions: string;
researchFirst?: boolean;
projectPath?: string;
adrDirectory?: string;
},
ctx // ✅ Pass context to tool function for progress updates
);
}
/**
* LLM database management tool implementation
*/
private async llmDatabaseManagement(
args: Record<string, unknown>,
context?: ToolContext
): Promise<CallToolResult> {
const ctx = context || createNoOpContext();
if (!('database' in args) || !('action' in args) || !('llmInstructions' in args)) {
throw new McpAdrError(
'Missing required parameters: database, action, llmInstructions',
'INVALID_ARGUMENTS'
);
}
ctx.info('🗄️ Starting LLM-managed database operation...');
ctx.report_progress(0, 100);
const { llmDatabaseManagement } = await import('./tools/llm-database-management-tool.js');
return await llmDatabaseManagement(
args as {
database: 'postgresql' | 'mongodb' | 'redis' | 'mysql' | 'mariadb';
action: string;
parameters?: Record<string, any>;
llmInstructions: string;
researchFirst?: boolean;
projectPath?: string;
adrDirectory?: string;
},
ctx // ✅ Pass context to tool function for progress updates
);
}
/**
* Deployment analysis tool implementation
*/
private async analyzeDeploymentProgress(args: Record<string, unknown>): Promise<CallToolResult> {
const { analyzeDeploymentProgress } = await import('./tools/deployment-analysis-tool.js');
return await analyzeDeploymentProgress(args);
}
/**
* Apply content masking to MCP response
*/
/**
* Track memory operations performed by tools
*/
private async trackMemoryOperations(
toolName: string,
parameters: any,
result: any,
success: boolean
): Promise<void> {
try {
// Check if memory integration was enabled and used
if (parameters?.enableMemoryIntegration === false) {
return; // Memory integration was explicitly disabled
}
// Extract memory operation information from result
const memoryOps = this.extractMemoryOperations(toolName, parameters, result);
if (memoryOps.length > 0) {
// Store memory operation tracking in knowledge graph
for (const op of memoryOps) {
await this.kgManager.addMemoryExecution(
toolName,
op.action,
op.entityType,
success && op.success,
op.details
);
}
}
} catch (error) {
// Don't let memory tracking errors break execution
console.error('[WARN] Memory operation tracking failed:', error);
}
}
/**
* Extract memory operation details from tool execution
*/
private extractMemoryOperations(toolName: string, parameters: any, result: any): any[] {
const operations: any[] = [];
// Define memory-enabled tools and their expected operations
const memoryEnabledTools = {
analyze_content_security: {
entityType: 'security_pattern',
actions: ['store_pattern', 'analyze_institutional_security', 'track_evolution'],
},
analyze_environment: {
entityType: 'environment_snapshot',
actions: ['store_snapshot', 'analyze_trends', 'compare_configurations'],
},
deployment_readiness: {
entityType: 'deployment_assessment',
actions: ['store_assessment', 'migrate_history', 'analyze_patterns'],
},
troubleshoot_guided_workflow: {
entityType: 'troubleshooting_session',
actions: ['store_session', 'pattern_recognition', 'suggest_adrs', 'generate_research'],
},
};
// Check if this tool supports memory operations
const toolConfig = memoryEnabledTools[toolName as keyof typeof memoryEnabledTools];
if (!toolConfig) {
return operations; // Tool doesn't support memory operations
}
// Extract memory operation details from result
if (result?.memoryIntegration) {
const memoryInfo = result.memoryIntegration;
// Pattern entity storage operation
if (memoryInfo.entityStored || memoryInfo.patternStored) {
operations.push({
action: 'entity_storage',
entityType: toolConfig.entityType,
success: memoryInfo.storageSuccess !== false,
details: {
entityId: memoryInfo.entityId || memoryInfo.patternId,
entityCount: memoryInfo.entityCount || 1,
storageMethod: memoryInfo.storageMethod || 'standard',
},
});
}
// Historical analysis operation
if (memoryInfo.historicalAnalysis || memoryInfo.trendAnalysis) {
operations.push({
action: 'historical_analysis',
entityType: toolConfig.entityType,
success: memoryInfo.analysisSuccess !== false,
details: {
analysisType: memoryInfo.analysisType || 'trend_analysis',
entitiesAnalyzed: memoryInfo.entitiesAnalyzed || 0,
insights: memoryInfo.insights || [],
},
});
}
// Evolution tracking operation
if (memoryInfo.evolutionTracking) {
operations.push({
action: 'evolution_tracking',
entityType: toolConfig.entityType,
success: memoryInfo.evolutionSuccess !== false,
details: {
improvements: memoryInfo.improvements || [],
degradations: memoryInfo.degradations || [],
recommendations: memoryInfo.recommendations || [],
},
});
}
// Migration operation (for deployment readiness)
if (memoryInfo.migrationCompleted) {
operations.push({
action: 'data_migration',
entityType: toolConfig.entityType,
success: memoryInfo.migrationSuccess !== false,
details: {
migratedRecords: memoryInfo.migratedRecords || 0,
migrationMethod: memoryInfo.migrationMethod || 'json_to_memory',
},
});
}
}
// If no specific memory integration info, infer from parameters
if (operations.length === 0 && parameters?.enableMemoryIntegration !== false) {
// Default assumption: entity was stored
operations.push({
action: 'entity_storage',
entityType: toolConfig.entityType,
success: true, // Assume success if no explicit info
details: {
entityCount: 1,
storageMethod: 'inferred',
note: 'Memory operation inferred from tool execution',
},
});
}
return operations;
}
/**
* Track tool execution in knowledge graph
*/
private async trackToolExecution(
toolName: string,
parameters: any,
result: any,
success: boolean,
error?: string
): Promise<void> {
try {
// Extract intentId from metadata if available
let intentId: string | undefined;
if (result?.metadata?.intentId) {
intentId = result.metadata.intentId;
} else {
// Check for active intents that might be related to this tool execution
const activeIntents = await this.kgManager.getActiveIntents();
if (activeIntents.length > 0) {
// Use the most recent active intent
const latestIntent = activeIntents[activeIntents.length - 1];
if (latestIntent) {
intentId = latestIntent.intentId;
}
}
}
// If no intent found, create a standalone execution record
if (!intentId) {
// Extract human request from conversation context if available
let humanRequest = `Standalone tool execution: ${toolName}`;
if (parameters?.conversationContext?.humanRequest) {
humanRequest = parameters.conversationContext.humanRequest;
}
intentId = await this.kgManager.createIntent(
humanRequest,
[`Execute ${toolName}`, 'Complete tool operation'],
'medium'
);
}
// Determine tasks created/modified from tool operation
const todoTasksCreated: string[] = [];
const todoTasksModified: string[] = [];
// Extract task information from result metadata
if (result?.metadata) {
if (result.metadata.tasksCreated) {
todoTasksCreated.push(...result.metadata.tasksCreated);
}
if (result.metadata.tasksModified) {
todoTasksModified.push(...result.metadata.tasksModified);
}
if (result.metadata.taskIds) {
todoTasksModified.push(...result.metadata.taskIds);
}
}
// Track memory operations if present
await this.trackMemoryOperations(toolName, parameters, result, success);
// Store execution in knowledge graph
await this.kgManager.addToolExecution(
intentId,
toolName,
parameters,
result,
success,
todoTasksCreated,
todoTasksModified,
error
);
// If execution completed successfully, update intent status
if (success && !error) {
// Check if this might be the final tool in a chain
const intent = await this.kgManager.getIntentById(intentId);
if (intent && intent.currentStatus === 'executing') {
// Simple heuristic: if tool is a "completion" type tool, mark intent as completed
const completionTools = ['smart_git_push', 'generate_deployment_guidance', 'smart_score'];
if (completionTools.includes(toolName)) {
await this.kgManager.updateIntentStatus(intentId, 'completed');
}
}
}
} catch (trackingError) {
// Don't let tracking errors break tool execution
console.error('[WARN] Knowledge graph tracking failed:', trackingError);
}
}
private async applyOutputMasking(response: any): Promise<any> {
try {
return await maskMcpResponse(response, this.maskingConfig);
} catch (error) {
// If masking fails, log warning and return original response
// Log to stderr to avoid corrupting MCP protocol
console.error('[WARN] Output masking failed:', error);
return response;
}
}
/**
* Enrich response with state reinforcement and apply masking
*
* Implements Phase 2 of context decay mitigation by injecting
* context reminders every N turns or when response exceeds token threshold.
*
* Phase 3 extension: Records conversation turns to structured external memory.
*/
private async enrichResponseWithStateReinforcement(
response: CallToolResult,
toolName?: string,
toolArgs?: any
): Promise<CallToolResult> {
const startTime = Date.now();
try {
// Extract text content from response
const textContent = response.content
.filter((item): item is { type: 'text'; text: string } => item.type === 'text')
.map(item => item.text)
.join('\n\n');
if (!textContent) {
// No text content to enrich, just apply masking
return await this.applyOutputMasking(response);
}
// Enrich with state reinforcement (Phase 2)
const enriched = await this.stateReinforcementManager.enrichResponseWithContext(textContent);
// Prepare final response
let finalResponse: CallToolResult;
// Replace text content with enriched version if context was injected
if (enriched.contextInjected) {
finalResponse = {
...response,
content: response.content.map(item => {
if (item.type === 'text') {
return {
type: 'text',
text: enriched.enrichedContent,
};
}
return item;
}),
};
} else {
finalResponse = response;
}
// Record conversation turn (Phase 3: Structured External Memory)
if (toolName) {
const duration = Date.now() - startTime;
// Check if response has expandableId (from tiered response)
const expandableIdMatch = textContent.match(/expandableId:\s*(\S+)/);
const expandableId = expandableIdMatch ? expandableIdMatch[1] : undefined;
await this.conversationMemoryManager.recordTurn(
{
type: 'tool_call',
toolName,
toolArgs,
},
{
content: enriched.enrichedContent || textContent,
tokenCount: enriched.tokenCount,
contextInjected: enriched.contextInjected,
...(expandableId ? { expandableId } : {}),
},
{
duration,
cacheHit: false, // Could be enhanced to track cache hits
errorOccurred: false,
}
);
this.logger.debug(`Conversation turn recorded for ${toolName}`, 'McpAdrAnalysisServer', {
turnNumber: enriched.turnNumber,
});
}
// Apply masking to final response
return await this.applyOutputMasking(finalResponse);
} catch (error) {
this.logger.error(
'State reinforcement or conversation recording failed, returning original response',
'McpAdrAnalysisServer',
error instanceof Error ? error : undefined
);
// Fallback to just masking if enrichment fails
return await this.applyOutputMasking(response);
}
}
/**
* Read MCP resource with prompt-driven caching
*/
private async readResource(uri: string): Promise<any> {
try {
// Import resource router and templated resources (ensures routes are registered)
const { resourceRouter } = await import('./resources/resource-router.js');
// Import templated resources to register routes
await import('./resources/adr-by-id-resource.js');
await import('./resources/research-by-topic-resource.js');
await import('./resources/todo-by-id-resource.js');
await import('./resources/rule-by-id-resource.js');
await import('./resources/technology-by-name-resource.js');
await import('./resources/pattern-by-name-resource.js');
// Try routing first (handles templated resources)
if (resourceRouter.canRoute(uri)) {
const result = await resourceRouter.route(uri);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
// Fall back to static resource handling
// Parse URI to determine resource type and parameters
const url = new globalThis.URL(uri);
const resourceType = url.pathname.replace('/', '');
const params = Object.fromEntries(url.searchParams.entries());
switch (resourceType) {
case 'architectural_knowledge_graph': {
const { generateArchitecturalKnowledgeGraph } = await import('./resources/index.js');
const projectPath = params['projectPath'] || process.cwd();
// Generate resource directly (caching is now handled through AI delegation)
const result = await generateArchitecturalKnowledgeGraph(projectPath);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
};
}
case 'analysis_report': {
const { generateAnalysisReport } = await import('./resources/index.js');
const projectPath = params['projectPath'] || process.cwd();
const focusAreas = params['focusAreas'] ? params['focusAreas'].split(',') : undefined;
// Generate resource directly (caching is now handled through AI delegation)
const result = await generateAnalysisReport(projectPath, focusAreas);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
};
}
case 'adr_list': {
const { generateAdrList } = await import('./resources/index.js');
const { getAdrDirectoryPath } = await import('./utils/config.js');
const path = await import('path');
// Use absolute ADR path relative to project
const absoluteAdrPath = params['adrDirectory']
? path.resolve(this.config.projectPath, params['adrDirectory'])
: getAdrDirectoryPath(this.config);
// Generate resource directly (caching is now handled through AI delegation)
const result = await generateAdrList(absoluteAdrPath, this.config.projectPath);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
};
}
case 'todo_list': {
const { generateTodoListResource } = await import('./resources/todo-list-resource.js');
const result = await generateTodoListResource();
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'research_index': {
const { generateResearchIndexResource } = await import(
'./resources/research-index-resource.js'
);
const result = await generateResearchIndexResource();
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'rule_catalog': {
const { generateRuleCatalogResource } = await import(
'./resources/rule-catalog-resource.js'
);
const result = await generateRuleCatalogResource();
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'rule_generation': {
const { generateRuleGenerationResource } = await import(
'./resources/rule-generation-resource.js'
);
const result = await generateRuleGenerationResource(undefined, url.searchParams);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'project_status': {
const { generateProjectStatusResource } = await import(
'./resources/project-status-resource.js'
);
const result = await generateProjectStatusResource();
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'deployment_status': {
const { generateDeploymentStatusResource } = await import(
'./resources/deployment-status-resource.js'
);
const result = await generateDeploymentStatusResource(undefined, url.searchParams);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'environment_analysis': {
const { generateEnvironmentAnalysisResource } = await import(
'./resources/environment-analysis-resource.js'
);
const result = await generateEnvironmentAnalysisResource(undefined, url.searchParams);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'memory_snapshots': {
const { generateMemorySnapshotsResource } = await import(
'./resources/memory-snapshots-resource.js'
);
const result = await generateMemorySnapshotsResource(undefined, url.searchParams);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'project_metrics': {
const { generateProjectMetricsResource } = await import(
'./resources/project-metrics-resource.js'
);
const result = await generateProjectMetricsResource();
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'deployment_history': {
const { generateDeploymentHistoryResource } = await import(
'./resources/deployment-history-resource.js'
);
const result = await generateDeploymentHistoryResource(undefined, url.searchParams);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
case 'code_quality': {
const { generateCodeQualityResource } = await import(
'./resources/code-quality-resource.js'
);
const result = await generateCodeQualityResource(undefined, url.searchParams);
return {
contents: [
{
uri,
mimeType: result.contentType,
text: JSON.stringify(result.data, null, 2),
},
],
_meta: {
lastModified: result.lastModified,
etag: result.etag,
cacheKey: result.cacheKey,
},
};
}
default:
throw new McpAdrError(`Unknown resource type: ${resourceType}`, 'UNKNOWN_RESOURCE');
}
} catch (error) {
if (error instanceof McpAdrError) {
throw error;
}
throw new McpAdrError(
`Failed to read resource: ${error instanceof Error ? error.message : String(error)}`,
'RESOURCE_ERROR'
);
}
}
/**
* Start the server
*/
async start(): Promise<void> {
// Validate configuration before starting
await this.validateConfiguration();
// Initialize memory entity manager
await this.memoryEntityManager.initialize();
this.logger.info('Memory Entity Manager initialized', 'McpAdrAnalysisServer');
// Initialize conversation memory manager (Phase 3: Structured External Memory)
await this.conversationMemoryManager.initialize();
this.logger.info('Phase 3 (Structured External Memory) initialized', 'McpAdrAnalysisServer');
// Generate initial server context file
try {
await this.contextGenerator.writeContextFile(
this.kgManager,
this.memoryEntityManager,
this.conversationMemoryManager
);
this.logger.info(
'Server context file generated at .mcp-server-context.md',
'McpAdrAnalysisServer'
);
} catch (error) {
this.logger.warn('Failed to generate initial server context file', 'McpAdrAnalysisServer', {
error: error instanceof Error ? error.message : String(error),
});
}
const transport = new StdioServerTransport();
await this.server.connect(transport);
// Keep the process alive
process.on('SIGINT', async () => {
await this.server.close();
process.exit(0);
});
}
/**
* File system tool implementations
*/
/**
* List accessible roots (MCP best practice)
*/
private async listRoots(): Promise<CallToolResult> {
const roots = this.rootManager.listRoots();
const rootsList = roots
.map(r => `### ${r.name}\n\n**Path**: \`${r.path}\`\n\n**Description**: ${r.description}\n`)
.join('\n');
return {
content: [
{
type: 'text',
text: `# Available File System Roots\n\nThese are the directories that can be accessed by this MCP server.\n\n${rootsList}\nUse these paths with \`read_directory\` and \`read_file\` tools to explore and access files.`,
},
],
};
}
/**
* Read directory contents (MCP best practice for autonomous file discovery)
*/
private async readDirectory(args: { path?: string }): Promise<CallToolResult> {
const targetPath = args.path || this.config.projectPath;
try {
const path = await import('path');
const resolvedPath = path.resolve(targetPath);
// Security check: ensure path is within accessible roots
if (!this.rootManager.isPathAllowed(resolvedPath)) {
const roots = this.rootManager.listRoots();
const rootList = roots.map(r => ` - ${r.name}: ${r.path}`).join('\n');
throw new McpAdrError(
`Access denied: Path '${targetPath}' is outside accessible roots.\n\nAccessible roots:\n${rootList}\n\nUse list_roots tool for more details.`,
'ACCESS_DENIED'
);
}
const { readdir } = await import('fs/promises');
const entries = await readdir(resolvedPath, { withFileTypes: true });
const files = entries.filter(e => e.isFile()).map(e => `📄 ${e.name}`);
const dirs = entries.filter(e => e.isDirectory()).map(e => `📁 ${e.name}/`);
const root = this.rootManager.getRootForPath(resolvedPath);
const relPath = this.rootManager.getRelativePathFromRoot(resolvedPath);
const filesList = files.length > 0 ? files.join('\n') : '(no files)';
const dirsList = dirs.length > 0 ? dirs.join('\n') : '(no directories)';
return {
content: [
{
type: 'text',
text: `# Directory: ${targetPath}\n\n**Root**: ${root?.name}\n**Relative Path**: ${relPath || '/'}\n**Full Path**: \`${resolvedPath}\`\n\n## Directories (${dirs.length})\n\n${dirsList}\n\n## Files (${files.length})\n\n${filesList}`,
},
],
};
} catch (error) {
throw new McpAdrError(
`Failed to read directory: ${error instanceof Error ? error.message : String(error)}`,
'DIRECTORY_READ_ERROR'
);
}
}
private async readFile(args: ReadFileArgs): Promise<CallToolResult> {
const { filePath } = args;
try {
const fs = await import('fs/promises');
const path = await import('path');
// Resolve path (handle both relative and absolute paths)
const safePath = path.resolve(filePath);
// Security check: ensure path is within accessible roots
if (!this.rootManager.isPathAllowed(safePath)) {
const roots = this.rootManager.listRoots();
const rootList = roots.map(r => ` - ${r.name}: ${r.path}`).join('\n');
throw new McpAdrError(
`Access denied: Path '${filePath}' is outside accessible roots.\n\nAccessible roots:\n${rootList}\n\nUse list_roots tool for more details.`,
'ACCESS_DENIED'
);
}
const content = await fs.readFile(safePath, 'utf-8');
return {
content: [
{
type: 'text',
text: content,
},
],
};
} catch (error) {
throw new McpAdrError(
`Failed to read file: ${error instanceof Error ? error.message : String(error)}`,
'FILE_READ_ERROR'
);
}
}
private async writeFile(args: WriteFileArgs): Promise<CallToolResult> {
const { filePath, content } = args;
try {
const fs = await import('fs/promises');
const path = await import('path');
// Resolve path relative to project path for security
const safePath = path.resolve(this.config.projectPath, filePath);
// Security check: ensure path is within project directory
if (!safePath.startsWith(this.config.projectPath)) {
throw new McpAdrError('Access denied: Path is outside project directory', 'ACCESS_DENIED');
}
// Ensure directory exists
await fs.mkdir(path.dirname(safePath), { recursive: true });
// Write file
await fs.writeFile(safePath, content, 'utf-8');
return {
content: [
{
type: 'text',
text: `Successfully wrote to ${filePath}`,
},
],
};
} catch (error) {
throw new McpAdrError(
`Failed to write file: ${error instanceof Error ? error.message : String(error)}`,
'FILE_WRITE_ERROR'
);
}
}
private async listDirectory(args: Record<string, unknown>): Promise<CallToolResult> {
const { path: dirPath } = args;
try {
const fs = await import('fs/promises');
const path = await import('path');
// Resolve path relative to project path for security
const safePath = path.resolve(this.config.projectPath, dirPath as string);
// Security check: ensure path is within project directory
if (!safePath.startsWith(this.config.projectPath)) {
throw new McpAdrError('Access denied: Path is outside project directory', 'ACCESS_DENIED');
}
const entries = await fs.readdir(safePath, { withFileTypes: true });
const fileList = entries.map(entry => ({
name: entry.name,
type: entry.isDirectory() ? 'directory' : 'file',
path: path.join(dirPath as string, entry.name),
}));
return {
content: [
{
type: 'text',
text: JSON.stringify(fileList, null, 2),
},
],
};
} catch (error) {
throw new McpAdrError(
`Failed to list directory: ${error instanceof Error ? error.message : String(error)}`,
'DIRECTORY_LIST_ERROR'
);
}
}
private async generateDeploymentGuidance(args: Record<string, unknown>): Promise<CallToolResult> {
try {
const { generateDeploymentGuidance } = await import('./tools/deployment-guidance-tool.js');
return await generateDeploymentGuidance(args);
} catch (error) {
throw new McpAdrError(
`Deployment guidance generation failed: ${error instanceof Error ? error.message : String(error)}`,
'DEPLOYMENT_GUIDANCE_ERROR'
);
}
}
private async smartGitPush(args: Record<string, unknown>): Promise<CallToolResult> {
try {
const { smartGitPush } = await import('./tools/smart-git-push-tool-v2.js');
return await smartGitPush(args);
} catch (error) {
throw new McpAdrError(
`Smart git push failed: ${error instanceof Error ? error.message : String(error)}`,
'SMART_GIT_PUSH_ERROR'
);
}
}
private async deploymentReadiness(args: Record<string, unknown>): Promise<CallToolResult> {
try {
const { deploymentReadiness } = await import('./tools/deployment-readiness-tool.js');
return await deploymentReadiness(args);
} catch (error) {
throw new McpAdrError(
`Deployment readiness check failed: ${error instanceof Error ? error.message : String(error)}`,
'DEPLOYMENT_READINESS_ERROR'
);
}
}
private async troubleshootGuidedWorkflow(args: Record<string, unknown>): Promise<CallToolResult> {
try {
const { troubleshootGuidedWorkflow } = await import(
'./tools/troubleshoot-guided-workflow-tool.js'
);
return await troubleshootGuidedWorkflow(args as unknown as TodoManagementV2Args);
} catch (error) {
throw new McpAdrError(
`Troubleshoot guided workflow failed: ${error instanceof Error ? error.message : String(error)}`,
'TROUBLESHOOT_GUIDED_WORKFLOW_ERROR'
);
}
}
private async smartScore(_args: Record<string, unknown>): Promise<CallToolResult> {
// Smart score tool was removed - return deprecation message
return {
content: [
{
type: 'text',
text: `⚠️ **Smart Score Tool Deprecated**
This tool has been deprecated and replaced with memory-centric health scoring.
**Replacement:** The new MemoryHealthScoring system tracks:
- Memory quality and relevance
- Retrieval performance
- Entity relationship coherence
- Context utilization
- Decision alignment
**Migration:** Health scoring is now integrated into the knowledge graph and automatically calculated based on memory usage patterns.`,
},
],
isError: false,
};
}
private async mcpPlanning(args: Record<string, unknown>): Promise<CallToolResult> {
try {
const { mcpPlanning } = await import('./tools/mcp-planning-tool.js');
return await mcpPlanning(args);
} catch (error) {
throw new McpAdrError(
`MCP planning failed: ${error instanceof Error ? error.message : String(error)}`,
'MCP_PLANNING_ERROR'
);
}
}
private async memoryLoading(args: Record<string, unknown>): Promise<CallToolResult> {
try {
const { MemoryLoadingTool } = await import('./tools/memory-loading-tool.js');
const memoryTool = new MemoryLoadingTool();
return await memoryTool.execute(args);
} catch (error) {
throw new McpAdrError(
`Memory loading failed: ${error instanceof Error ? error.message : String(error)}`,
'MEMORY_LOADING_ERROR'
);
}
}
private async expandAnalysisSection(args: Record<string, unknown>): Promise<CallToolResult> {
try {
const { expandAnalysisSection } = await import('./tools/expand-analysis-tool.js');
return await expandAnalysisSection(args as any);
} catch (error) {
throw new McpAdrError(
`Failed to expand analysis: ${error instanceof Error ? error.message : String(error)}`,
'EXPAND_ANALYSIS_ERROR'
);
}
}
private async interactiveAdrPlanning(args: Record<string, unknown>): Promise<CallToolResult> {
try {
const { interactiveAdrPlanning } = await import('./tools/interactive-adr-planning-tool.js');
return await interactiveAdrPlanning(args);
} catch (error) {
throw new McpAdrError(
`Interactive ADR planning failed: ${error instanceof Error ? error.message : String(error)}`,
'INTERACTIVE_ADR_PLANNING_ERROR'
);
}
}
/**
* Tool chain orchestrator implementation
*/
private async toolChainOrchestrator(args: ToolChainOrchestratorArgs): Promise<CallToolResult> {
try {
const { toolChainOrchestrator } = await import('./tools/tool-chain-orchestrator.js');
return await toolChainOrchestrator(args as any);
} catch (error) {
throw new McpAdrError(
`Tool chain orchestration failed: ${error instanceof Error ? error.message : String(error)}`,
'TOOL_CHAIN_ORCHESTRATOR_ERROR'
);
}
}
/**
* Phase 3: Expand Memory Tool
* Retrieves and expands stored content from tiered responses
*/
private async expandMemory(args: any): Promise<CallToolResult> {
try {
const { expandMemory } = await import('./tools/conversation-memory-tool.js');
return await expandMemory(args, this.conversationMemoryManager);
} catch (error) {
throw new McpAdrError(
`Memory expansion failed: ${error instanceof Error ? error.message : String(error)}`,
'MEMORY_EXPANSION_ERROR'
);
}
}
/**
* Phase 3: Query Conversation History Tool
* Searches and retrieves conversation sessions
*/
private async queryConversationHistory(args: any): Promise<CallToolResult> {
try {
const { queryConversationHistory } = await import('./tools/conversation-memory-tool.js');
return await queryConversationHistory(args, this.conversationMemoryManager);
} catch (error) {
throw new McpAdrError(
`Conversation history query failed: ${error instanceof Error ? error.message : String(error)}`,
'CONVERSATION_QUERY_ERROR'
);
}
}
/**
* Phase 3: Get Conversation Snapshot Tool
* Retrieves current conversation context
*/
private async getConversationSnapshot(args: any): Promise<CallToolResult> {
try {
const { getConversationSnapshot } = await import('./tools/conversation-memory-tool.js');
return await getConversationSnapshot(args, this.conversationMemoryManager);
} catch (error) {
throw new McpAdrError(
`Conversation snapshot retrieval failed: ${error instanceof Error ? error.message : String(error)}`,
'SNAPSHOT_ERROR'
);
}
}
/**
* Phase 3: Get Memory Statistics Tool
* Retrieves conversation memory statistics
*/
private async getMemoryStats(): Promise<CallToolResult> {
try {
const { getMemoryStats } = await import('./tools/conversation-memory-tool.js');
return await getMemoryStats(this.conversationMemoryManager);
} catch (error) {
throw new McpAdrError(
`Memory stats retrieval failed: ${error instanceof Error ? error.message : String(error)}`,
'MEMORY_STATS_ERROR'
);
}
}
/**
* Get Server Context Tool
* Generates comprehensive server context file for LLM @ referencing
*/
private async getServerContext(args: any): Promise<CallToolResult> {
try {
const { getServerContext } = await import('./tools/get-server-context-tool.js');
return await getServerContext(
args,
this.kgManager,
this.memoryEntityManager,
this.conversationMemoryManager
);
} catch (error) {
throw new McpAdrError(
`Server context generation failed: ${error instanceof Error ? error.message : String(error)}`,
'SERVER_CONTEXT_ERROR'
);
}
}
}
/**
* Main execution function for the MCP ADR Analysis Server
*
* @description Initializes and starts the MCP server with proper configuration,
* error handling, and graceful shutdown. Handles command line arguments for
* help, version, and test modes.
*
* @returns {Promise<void>} Resolves when server shuts down gracefully
*
* @throws {Error} When server initialization fails or configuration is invalid
*
* @example
* ```typescript
* // Start the server (typically called from CLI)
* await main();
* ```
*
* @since 1.0.0
* @category Main
*/
async function main(): Promise<void> {
const args = process.argv.slice(2);
// Handle command line arguments
if (args.includes('--help') || args.includes('-h')) {
console.log(`
MCP ADR Analysis Server v${SERVER_INFO.version}
Usage: mcp-adr-analysis-server [options]
Options:
--help, -h Show this help message
--version, -v Show version information
--test Run health check and exit
--config Show configuration and exit
Environment Variables:
PROJECT_PATH Path to project directory (default: current directory)
ADR_DIRECTORY ADR directory relative to project (default: docs/adrs)
LOG_LEVEL Logging level: DEBUG, INFO, WARN, ERROR (default: INFO)
CACHE_ENABLED Enable caching: true, false (default: true)
Examples:
mcp-adr-analysis-server # Start MCP server
PROJECT_PATH=/path/to/project mcp-adr-analysis-server
mcp-adr-analysis-server --test # Health check
`);
process.exit(0);
}
if (args.includes('--version') || args.includes('-v')) {
console.log(`MCP ADR Analysis Server v${SERVER_INFO.version}`);
process.exit(0);
}
try {
const server = new McpAdrAnalysisServer();
if (args.includes('--test')) {
console.log('🔍 Running health check...');
await server.healthCheck();
console.log('✅ Health check passed - server can start successfully');
process.exit(0);
}
if (args.includes('--config')) {
console.log('📋 Server configuration validated');
process.exit(0);
}
// Normal server startup
await server.start();
} catch (error) {
console.error('❌ MCP server failed to start');
console.error('Error:', error instanceof Error ? error.message : String(error));
process.exit(1);
}
}
// Start the server if this file is run directly
// Jest-compatible check: avoid import.meta.url which Jest cannot handle
// Handle both direct execution and npm global package symlinks
if (
process.argv[1] &&
(process.argv[1].endsWith('index.js') ||
process.argv[1].endsWith('index.ts') ||
process.argv[1].endsWith('mcp-adr-analysis-server'))
) {
main().catch(error => {
console.error('Unhandled error:', error);
process.exit(1);
});
}
// Test comment for pre-commit hook
```