auryn-http 0.1.0__tar.gz

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
@@ -0,0 +1,56 @@
1
+ # Python-generated files
2
+ __pycache__/
3
+ *.py[oc]
4
+ build/
5
+ dist/
6
+ wheels/
7
+ *.egg-info
8
+
9
+ # Virtual environments
10
+ .venv
11
+
12
+ # Test/coverage artifacts
13
+ .coverage
14
+ .pytest_cache/
15
+ *.db
16
+
17
+ # Embedded-graph working dir written by `auryn quickstart` (e.g. quickstart/.auryn/)
18
+ .auryn/
19
+
20
+ # .NET build output (roslyn-extractor tool + C# test fixtures)
21
+ bin/
22
+ obj/
23
+
24
+ # Demo sample repos are generated by their setup.py / run_demo.py
25
+ demo/csharp-git/sample-repo/
26
+
27
+
28
+ # Stray FalkorDB/Redis snapshot (regenerated at runtime; never upload)
29
+ dump.rdb
30
+ *.rdb
31
+
32
+ # Deploy bundles (build artifacts)
33
+ auryn-plsql-deploy.zip
34
+ auryn-deploy.zip
35
+
36
+ # Agent-benchmark run outputs (per-run JSON logs, captured claude-config, transcripts)
37
+ benchmarks/agent/results/
38
+ benchmarks/agent/results-swe/
39
+ benchmarks/agent/results-corpus/
40
+ benchmarks/agent/results-abcd-easy/
41
+ benchmarks/agent/results-abcd-hard/
42
+ benchmarks/hook/results/
43
+ benchmarks/results/
44
+
45
+ # macOS Finder metadata
46
+ .DS_Store
47
+
48
+ # Local operator docs (client/prospect restore & VM setup) — never publish
49
+ RESTORE-*.md
50
+ INSTALL-ON-*.md
51
+
52
+ # Private, non-public hooks / work kept out of the open-source release
53
+ private/
54
+
55
+ # WIP demo not part of the public launch (kept local)
56
+ demo/auryn-tour/
@@ -0,0 +1,557 @@
1
+ Server Side Public License
2
+ VERSION 1, OCTOBER 16, 2018
3
+
4
+ Copyright © 2018 MongoDB, Inc.
5
+
6
+ Everyone is permitted to copy and distribute verbatim copies of this
7
+ license document, but changing it is not allowed.
8
+
9
+ TERMS AND CONDITIONS
10
+
11
+ 0. Definitions.
12
+
13
+ “This License” refers to Server Side Public License.
14
+
15
+ “Copyright” also means copyright-like laws that apply to other kinds of
16
+ works, such as semiconductor masks.
17
+
18
+ “The Program” refers to any copyrightable work licensed under this
19
+ License. Each licensee is addressed as “you”. “Licensees” and
20
+ “recipients” may be individuals or organizations.
21
+
22
+ To “modify” a work means to copy from or adapt all or part of the work in
23
+ a fashion requiring copyright permission, other than the making of an
24
+ exact copy. The resulting work is called a “modified version” of the
25
+ earlier work or a work “based on” the earlier work.
26
+
27
+ A “covered work” means either the unmodified Program or a work based on
28
+ the Program.
29
+
30
+ To “propagate” a work means to do anything with it that, without
31
+ permission, would make you directly or secondarily liable for
32
+ infringement under applicable copyright law, except executing it on a
33
+ computer or modifying a private copy. Propagation includes copying,
34
+ distribution (with or without modification), making available to the
35
+ public, and in some countries other activities as well.
36
+
37
+ To “convey” a work means any kind of propagation that enables other
38
+ parties to make or receive copies. Mere interaction with a user through a
39
+ computer network, with no transfer of a copy, is not conveying.
40
+
41
+ An interactive user interface displays “Appropriate Legal Notices” to the
42
+ extent that it includes a convenient and prominently visible feature that
43
+ (1) displays an appropriate copyright notice, and (2) tells the user that
44
+ there is no warranty for the work (except to the extent that warranties
45
+ are provided), that licensees may convey the work under this License, and
46
+ how to view a copy of this License. If the interface presents a list of
47
+ user commands or options, such as a menu, a prominent item in the list
48
+ meets this criterion.
49
+
50
+ 1. Source Code.
51
+
52
+ The “source code” for a work means the preferred form of the work for
53
+ making modifications to it. “Object code” means any non-source form of a
54
+ work.
55
+
56
+ A “Standard Interface” means an interface that either is an official
57
+ standard defined by a recognized standards body, or, in the case of
58
+ interfaces specified for a particular programming language, one that is
59
+ widely used among developers working in that language. The “System
60
+ Libraries” of an executable work include anything, other than the work as
61
+ a whole, that (a) is included in the normal form of packaging a Major
62
+ Component, but which is not part of that Major Component, and (b) serves
63
+ only to enable use of the work with that Major Component, or to implement
64
+ a Standard Interface for which an implementation is available to the
65
+ public in source code form. A “Major Component”, in this context, means a
66
+ major essential component (kernel, window system, and so on) of the
67
+ specific operating system (if any) on which the executable work runs, or
68
+ a compiler used to produce the work, or an object code interpreter used
69
+ to run it.
70
+
71
+ The “Corresponding Source” for a work in object code form means all the
72
+ source code needed to generate, install, and (for an executable work) run
73
+ the object code and to modify the work, including scripts to control
74
+ those activities. However, it does not include the work's System
75
+ Libraries, or general-purpose tools or generally available free programs
76
+ which are used unmodified in performing those activities but which are
77
+ not part of the work. For example, Corresponding Source includes
78
+ interface definition files associated with source files for the work, and
79
+ the source code for shared libraries and dynamically linked subprograms
80
+ that the work is specifically designed to require, such as by intimate
81
+ data communication or control flow between those subprograms and other
82
+ parts of the work.
83
+
84
+ The Corresponding Source need not include anything that users can
85
+ regenerate automatically from other parts of the Corresponding Source.
86
+
87
+ The Corresponding Source for a work in source code form is that same work.
88
+
89
+ 2. Basic Permissions.
90
+
91
+ All rights granted under this License are granted for the term of
92
+ copyright on the Program, and are irrevocable provided the stated
93
+ conditions are met. This License explicitly affirms your unlimited
94
+ permission to run the unmodified Program, subject to section 13. The
95
+ output from running a covered work is covered by this License only if the
96
+ output, given its content, constitutes a covered work. This License
97
+ acknowledges your rights of fair use or other equivalent, as provided by
98
+ copyright law. Subject to section 13, you may make, run and propagate
99
+ covered works that you do not convey, without conditions so long as your
100
+ license otherwise remains in force. You may convey covered works to
101
+ others for the sole purpose of having them make modifications exclusively
102
+ for you, or provide you with facilities for running those works, provided
103
+ that you comply with the terms of this License in conveying all
104
+ material for which you do not control copyright. Those thus making or
105
+ running the covered works for you must do so exclusively on your
106
+ behalf, under your direction and control, on terms that prohibit them
107
+ from making any copies of your copyrighted material outside their
108
+ relationship with you.
109
+
110
+ Conveying under any other circumstances is permitted solely under the
111
+ conditions stated below. Sublicensing is not allowed; section 10 makes it
112
+ unnecessary.
113
+
114
+ 3. Protecting Users' Legal Rights From Anti-Circumvention Law.
115
+
116
+ No covered work shall be deemed part of an effective technological
117
+ measure under any applicable law fulfilling obligations under article 11
118
+ of the WIPO copyright treaty adopted on 20 December 1996, or similar laws
119
+ prohibiting or restricting circumvention of such measures.
120
+
121
+ When you convey a covered work, you waive any legal power to forbid
122
+ circumvention of technological measures to the extent such circumvention is
123
+ effected by exercising rights under this License with respect to the
124
+ covered work, and you disclaim any intention to limit operation or
125
+ modification of the work as a means of enforcing, against the work's users,
126
+ your or third parties' legal rights to forbid circumvention of
127
+ technological measures.
128
+
129
+ 4. Conveying Verbatim Copies.
130
+
131
+ You may convey verbatim copies of the Program's source code as you
132
+ receive it, in any medium, provided that you conspicuously and
133
+ appropriately publish on each copy an appropriate copyright notice; keep
134
+ intact all notices stating that this License and any non-permissive terms
135
+ added in accord with section 7 apply to the code; keep intact all notices
136
+ of the absence of any warranty; and give all recipients a copy of this
137
+ License along with the Program. You may charge any price or no price for
138
+ each copy that you convey, and you may offer support or warranty
139
+ protection for a fee.
140
+
141
+ 5. Conveying Modified Source Versions.
142
+
143
+ You may convey a work based on the Program, or the modifications to
144
+ produce it from the Program, in the form of source code under the terms
145
+ of section 4, provided that you also meet all of these conditions:
146
+
147
+ a) The work must carry prominent notices stating that you modified it,
148
+ and giving a relevant date.
149
+
150
+ b) The work must carry prominent notices stating that it is released
151
+ under this License and any conditions added under section 7. This
152
+ requirement modifies the requirement in section 4 to “keep intact all
153
+ notices”.
154
+
155
+ c) You must license the entire work, as a whole, under this License to
156
+ anyone who comes into possession of a copy. This License will therefore
157
+ apply, along with any applicable section 7 additional terms, to the
158
+ whole of the work, and all its parts, regardless of how they are
159
+ packaged. This License gives no permission to license the work in any
160
+ other way, but it does not invalidate such permission if you have
161
+ separately received it.
162
+
163
+ d) If the work has interactive user interfaces, each must display
164
+ Appropriate Legal Notices; however, if the Program has interactive
165
+ interfaces that do not display Appropriate Legal Notices, your work
166
+ need not make them do so.
167
+
168
+ A compilation of a covered work with other separate and independent
169
+ works, which are not by their nature extensions of the covered work, and
170
+ which are not combined with it such as to form a larger program, in or on
171
+ a volume of a storage or distribution medium, is called an “aggregate” if
172
+ the compilation and its resulting copyright are not used to limit the
173
+ access or legal rights of the compilation's users beyond what the
174
+ individual works permit. Inclusion of a covered work in an aggregate does
175
+ not cause this License to apply to the other parts of the aggregate.
176
+
177
+ 6. Conveying Non-Source Forms.
178
+
179
+ You may convey a covered work in object code form under the terms of
180
+ sections 4 and 5, provided that you also convey the machine-readable
181
+ Corresponding Source under the terms of this License, in one of these
182
+ ways:
183
+
184
+ a) Convey the object code in, or embodied in, a physical product
185
+ (including a physical distribution medium), accompanied by the
186
+ Corresponding Source fixed on a durable physical medium customarily
187
+ used for software interchange.
188
+
189
+ b) Convey the object code in, or embodied in, a physical product
190
+ (including a physical distribution medium), accompanied by a written
191
+ offer, valid for at least three years and valid for as long as you
192
+ offer spare parts or customer support for that product model, to give
193
+ anyone who possesses the object code either (1) a copy of the
194
+ Corresponding Source for all the software in the product that is
195
+ covered by this License, on a durable physical medium customarily used
196
+ for software interchange, for a price no more than your reasonable cost
197
+ of physically performing this conveying of source, or (2) access to
198
+ copy the Corresponding Source from a network server at no charge.
199
+
200
+ c) Convey individual copies of the object code with a copy of the
201
+ written offer to provide the Corresponding Source. This alternative is
202
+ allowed only occasionally and noncommercially, and only if you received
203
+ the object code with such an offer, in accord with subsection 6b.
204
+
205
+ d) Convey the object code by offering access from a designated place
206
+ (gratis or for a charge), and offer equivalent access to the
207
+ Corresponding Source in the same way through the same place at no
208
+ further charge. You need not require recipients to copy the
209
+ Corresponding Source along with the object code. If the place to copy
210
+ the object code is a network server, the Corresponding Source may be on
211
+ a different server (operated by you or a third party) that supports
212
+ equivalent copying facilities, provided you maintain clear directions
213
+ next to the object code saying where to find the Corresponding Source.
214
+ Regardless of what server hosts the Corresponding Source, you remain
215
+ obligated to ensure that it is available for as long as needed to
216
+ satisfy these requirements.
217
+
218
+ e) Convey the object code using peer-to-peer transmission, provided you
219
+ inform other peers where the object code and Corresponding Source of
220
+ the work are being offered to the general public at no charge under
221
+ subsection 6d.
222
+
223
+ A separable portion of the object code, whose source code is excluded
224
+ from the Corresponding Source as a System Library, need not be included
225
+ in conveying the object code work.
226
+
227
+ A “User Product” is either (1) a “consumer product”, which means any
228
+ tangible personal property which is normally used for personal, family,
229
+ or household purposes, or (2) anything designed or sold for incorporation
230
+ into a dwelling. In determining whether a product is a consumer product,
231
+ doubtful cases shall be resolved in favor of coverage. For a particular
232
+ product received by a particular user, “normally used” refers to a
233
+ typical or common use of that class of product, regardless of the status
234
+ of the particular user or of the way in which the particular user
235
+ actually uses, or expects or is expected to use, the product. A product
236
+ is a consumer product regardless of whether the product has substantial
237
+ commercial, industrial or non-consumer uses, unless such uses represent
238
+ the only significant mode of use of the product.
239
+
240
+ “Installation Information” for a User Product means any methods,
241
+ procedures, authorization keys, or other information required to install
242
+ and execute modified versions of a covered work in that User Product from
243
+ a modified version of its Corresponding Source. The information must
244
+ suffice to ensure that the continued functioning of the modified object
245
+ code is in no case prevented or interfered with solely because
246
+ modification has been made.
247
+
248
+ If you convey an object code work under this section in, or with, or
249
+ specifically for use in, a User Product, and the conveying occurs as part
250
+ of a transaction in which the right of possession and use of the User
251
+ Product is transferred to the recipient in perpetuity or for a fixed term
252
+ (regardless of how the transaction is characterized), the Corresponding
253
+ Source conveyed under this section must be accompanied by the
254
+ Installation Information. But this requirement does not apply if neither
255
+ you nor any third party retains the ability to install modified object
256
+ code on the User Product (for example, the work has been installed in
257
+ ROM).
258
+
259
+ The requirement to provide Installation Information does not include a
260
+ requirement to continue to provide support service, warranty, or updates
261
+ for a work that has been modified or installed by the recipient, or for
262
+ the User Product in which it has been modified or installed. Access
263
+ to a network may be denied when the modification itself materially
264
+ and adversely affects the operation of the network or violates the
265
+ rules and protocols for communication across the network.
266
+
267
+ Corresponding Source conveyed, and Installation Information provided, in
268
+ accord with this section must be in a format that is publicly documented
269
+ (and with an implementation available to the public in source code form),
270
+ and must require no special password or key for unpacking, reading or
271
+ copying.
272
+
273
+ 7. Additional Terms.
274
+
275
+ “Additional permissions” are terms that supplement the terms of this
276
+ License by making exceptions from one or more of its conditions.
277
+ Additional permissions that are applicable to the entire Program shall be
278
+ treated as though they were included in this License, to the extent that
279
+ they are valid under applicable law. If additional permissions apply only
280
+ to part of the Program, that part may be used separately under those
281
+ permissions, but the entire Program remains governed by this License
282
+ without regard to the additional permissions. When you convey a copy of
283
+ a covered work, you may at your option remove any additional permissions
284
+ from that copy, or from any part of it. (Additional permissions may be
285
+ written to require their own removal in certain cases when you modify the
286
+ work.) You may place additional permissions on material, added by you to
287
+ a covered work, for which you have or can give appropriate copyright
288
+ permission.
289
+
290
+ Notwithstanding any other provision of this License, for material you add
291
+ to a covered work, you may (if authorized by the copyright holders of
292
+ that material) supplement the terms of this License with terms:
293
+
294
+ a) Disclaiming warranty or limiting liability differently from the
295
+ terms of sections 15 and 16 of this License; or
296
+
297
+ b) Requiring preservation of specified reasonable legal notices or
298
+ author attributions in that material or in the Appropriate Legal
299
+ Notices displayed by works containing it; or
300
+
301
+ c) Prohibiting misrepresentation of the origin of that material, or
302
+ requiring that modified versions of such material be marked in
303
+ reasonable ways as different from the original version; or
304
+
305
+ d) Limiting the use for publicity purposes of names of licensors or
306
+ authors of the material; or
307
+
308
+ e) Declining to grant rights under trademark law for use of some trade
309
+ names, trademarks, or service marks; or
310
+
311
+ f) Requiring indemnification of licensors and authors of that material
312
+ by anyone who conveys the material (or modified versions of it) with
313
+ contractual assumptions of liability to the recipient, for any
314
+ liability that these contractual assumptions directly impose on those
315
+ licensors and authors.
316
+
317
+ All other non-permissive additional terms are considered “further
318
+ restrictions” within the meaning of section 10. If the Program as you
319
+ received it, or any part of it, contains a notice stating that it is
320
+ governed by this License along with a term that is a further restriction,
321
+ you may remove that term. If a license document contains a further
322
+ restriction but permits relicensing or conveying under this License, you
323
+ may add to a covered work material governed by the terms of that license
324
+ document, provided that the further restriction does not survive such
325
+ relicensing or conveying.
326
+
327
+ If you add terms to a covered work in accord with this section, you must
328
+ place, in the relevant source files, a statement of the additional terms
329
+ that apply to those files, or a notice indicating where to find the
330
+ applicable terms. Additional terms, permissive or non-permissive, may be
331
+ stated in the form of a separately written license, or stated as
332
+ exceptions; the above requirements apply either way.
333
+
334
+ 8. Termination.
335
+
336
+ You may not propagate or modify a covered work except as expressly
337
+ provided under this License. Any attempt otherwise to propagate or modify
338
+ it is void, and will automatically terminate your rights under this
339
+ License (including any patent licenses granted under the third paragraph
340
+ of section 11).
341
+
342
+ However, if you cease all violation of this License, then your license
343
+ from a particular copyright holder is reinstated (a) provisionally,
344
+ unless and until the copyright holder explicitly and finally terminates
345
+ your license, and (b) permanently, if the copyright holder fails to
346
+ notify you of the violation by some reasonable means prior to 60 days
347
+ after the cessation.
348
+
349
+ Moreover, your license from a particular copyright holder is reinstated
350
+ permanently if the copyright holder notifies you of the violation by some
351
+ reasonable means, this is the first time you have received notice of
352
+ violation of this License (for any work) from that copyright holder, and
353
+ you cure the violation prior to 30 days after your receipt of the notice.
354
+
355
+ Termination of your rights under this section does not terminate the
356
+ licenses of parties who have received copies or rights from you under
357
+ this License. If your rights have been terminated and not permanently
358
+ reinstated, you do not qualify to receive new licenses for the same
359
+ material under section 10.
360
+
361
+ 9. Acceptance Not Required for Having Copies.
362
+
363
+ You are not required to accept this License in order to receive or run a
364
+ copy of the Program. Ancillary propagation of a covered work occurring
365
+ solely as a consequence of using peer-to-peer transmission to receive a
366
+ copy likewise does not require acceptance. However, nothing other than
367
+ this License grants you permission to propagate or modify any covered
368
+ work. These actions infringe copyright if you do not accept this License.
369
+ Therefore, by modifying or propagating a covered work, you indicate your
370
+ acceptance of this License to do so.
371
+
372
+ 10. Automatic Licensing of Downstream Recipients.
373
+
374
+ Each time you convey a covered work, the recipient automatically receives
375
+ a license from the original licensors, to run, modify and propagate that
376
+ work, subject to this License. You are not responsible for enforcing
377
+ compliance by third parties with this License.
378
+
379
+ An “entity transaction” is a transaction transferring control of an
380
+ organization, or substantially all assets of one, or subdividing an
381
+ organization, or merging organizations. If propagation of a covered work
382
+ results from an entity transaction, each party to that transaction who
383
+ receives a copy of the work also receives whatever licenses to the work
384
+ the party's predecessor in interest had or could give under the previous
385
+ paragraph, plus a right to possession of the Corresponding Source of the
386
+ work from the predecessor in interest, if the predecessor has it or can
387
+ get it with reasonable efforts.
388
+
389
+ You may not impose any further restrictions on the exercise of the rights
390
+ granted or affirmed under this License. For example, you may not impose a
391
+ license fee, royalty, or other charge for exercise of rights granted
392
+ under this License, and you may not initiate litigation (including a
393
+ cross-claim or counterclaim in a lawsuit) alleging that any patent claim
394
+ is infringed by making, using, selling, offering for sale, or importing
395
+ the Program or any portion of it.
396
+
397
+ 11. Patents.
398
+
399
+ A “contributor” is a copyright holder who authorizes use under this
400
+ License of the Program or a work on which the Program is based. The work
401
+ thus licensed is called the contributor's “contributor version”.
402
+
403
+ A contributor's “essential patent claims” are all patent claims owned or
404
+ controlled by the contributor, whether already acquired or hereafter
405
+ acquired, that would be infringed by some manner, permitted by this
406
+ License, of making, using, or selling its contributor version, but do not
407
+ include claims that would be infringed only as a consequence of further
408
+ modification of the contributor version. For purposes of this definition,
409
+ “control” includes the right to grant patent sublicenses in a manner
410
+ consistent with the requirements of this License.
411
+
412
+ Each contributor grants you a non-exclusive, worldwide, royalty-free
413
+ patent license under the contributor's essential patent claims, to make,
414
+ use, sell, offer for sale, import and otherwise run, modify and propagate
415
+ the contents of its contributor version.
416
+
417
+ In the following three paragraphs, a “patent license” is any express
418
+ agreement or commitment, however denominated, not to enforce a patent
419
+ (such as an express permission to practice a patent or covenant not to
420
+ sue for patent infringement). To “grant” such a patent license to a party
421
+ means to make such an agreement or commitment not to enforce a patent
422
+ against the party.
423
+
424
+ If you convey a covered work, knowingly relying on a patent license, and
425
+ the Corresponding Source of the work is not available for anyone to copy,
426
+ free of charge and under the terms of this License, through a publicly
427
+ available network server or other readily accessible means, then you must
428
+ either (1) cause the Corresponding Source to be so available, or (2)
429
+ arrange to deprive yourself of the benefit of the patent license for this
430
+ particular work, or (3) arrange, in a manner consistent with the
431
+ requirements of this License, to extend the patent license to downstream
432
+ recipients. “Knowingly relying” means you have actual knowledge that, but
433
+ for the patent license, your conveying the covered work in a country, or
434
+ your recipient's use of the covered work in a country, would infringe
435
+ one or more identifiable patents in that country that you have reason
436
+ to believe are valid.
437
+
438
+ If, pursuant to or in connection with a single transaction or
439
+ arrangement, you convey, or propagate by procuring conveyance of, a
440
+ covered work, and grant a patent license to some of the parties receiving
441
+ the covered work authorizing them to use, propagate, modify or convey a
442
+ specific copy of the covered work, then the patent license you grant is
443
+ automatically extended to all recipients of the covered work and works
444
+ based on it.
445
+
446
+ A patent license is “discriminatory” if it does not include within the
447
+ scope of its coverage, prohibits the exercise of, or is conditioned on
448
+ the non-exercise of one or more of the rights that are specifically
449
+ granted under this License. You may not convey a covered work if you are
450
+ a party to an arrangement with a third party that is in the business of
451
+ distributing software, under which you make payment to the third party
452
+ based on the extent of your activity of conveying the work, and under
453
+ which the third party grants, to any of the parties who would receive the
454
+ covered work from you, a discriminatory patent license (a) in connection
455
+ with copies of the covered work conveyed by you (or copies made from
456
+ those copies), or (b) primarily for and in connection with specific
457
+ products or compilations that contain the covered work, unless you
458
+ entered into that arrangement, or that patent license was granted, prior
459
+ to 28 March 2007.
460
+
461
+ Nothing in this License shall be construed as excluding or limiting any
462
+ implied license or other defenses to infringement that may otherwise be
463
+ available to you under applicable patent law.
464
+
465
+ 12. No Surrender of Others' Freedom.
466
+
467
+ If conditions are imposed on you (whether by court order, agreement or
468
+ otherwise) that contradict the conditions of this License, they do not
469
+ excuse you from the conditions of this License. If you cannot use,
470
+ propagate or convey a covered work so as to satisfy simultaneously your
471
+ obligations under this License and any other pertinent obligations, then
472
+ as a consequence you may not use, propagate or convey it at all. For
473
+ example, if you agree to terms that obligate you to collect a royalty for
474
+ further conveying from those to whom you convey the Program, the only way
475
+ you could satisfy both those terms and this License would be to refrain
476
+ entirely from conveying the Program.
477
+
478
+ 13. Offering the Program as a Service.
479
+
480
+ If you make the functionality of the Program or a modified version
481
+ available to third parties as a service, you must make the Service Source
482
+ Code available via network download to everyone at no charge, under the
483
+ terms of this License. Making the functionality of the Program or
484
+ modified version available to third parties as a service includes,
485
+ without limitation, enabling third parties to interact with the
486
+ functionality of the Program or modified version remotely through a
487
+ computer network, offering a service the value of which entirely or
488
+ primarily derives from the value of the Program or modified version, or
489
+ offering a service that accomplishes for users the primary purpose of the
490
+ Program or modified version.
491
+
492
+ “Service Source Code” means the Corresponding Source for the Program or
493
+ the modified version, and the Corresponding Source for all programs that
494
+ you use to make the Program or modified version available as a service,
495
+ including, without limitation, management software, user interfaces,
496
+ application program interfaces, automation software, monitoring software,
497
+ backup software, storage software and hosting software, all such that a
498
+ user could run an instance of the service using the Service Source Code
499
+ you make available.
500
+
501
+ 14. Revised Versions of this License.
502
+
503
+ MongoDB, Inc. may publish revised and/or new versions of the Server Side
504
+ Public License from time to time. Such new versions will be similar in
505
+ spirit to the present version, but may differ in detail to address new
506
+ problems or concerns.
507
+
508
+ Each version is given a distinguishing version number. If the Program
509
+ specifies that a certain numbered version of the Server Side Public
510
+ License “or any later version” applies to it, you have the option of
511
+ following the terms and conditions either of that numbered version or of
512
+ any later version published by MongoDB, Inc. If the Program does not
513
+ specify a version number of the Server Side Public License, you may
514
+ choose any version ever published by MongoDB, Inc.
515
+
516
+ If the Program specifies that a proxy can decide which future versions of
517
+ the Server Side Public License can be used, that proxy's public statement
518
+ of acceptance of a version permanently authorizes you to choose that
519
+ version for the Program.
520
+
521
+ Later license versions may give you additional or different permissions.
522
+ However, no additional obligations are imposed on any author or copyright
523
+ holder as a result of your choosing to follow a later version.
524
+
525
+ 15. Disclaimer of Warranty.
526
+
527
+ THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
528
+ APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
529
+ HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM “AS IS” WITHOUT WARRANTY
530
+ OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
531
+ THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
532
+ PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
533
+ IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
534
+ ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
535
+
536
+ 16. Limitation of Liability.
537
+
538
+ IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
539
+ WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
540
+ THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING
541
+ ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF
542
+ THE USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO
543
+ LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU
544
+ OR THIRD PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER
545
+ PROGRAMS), EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE
546
+ POSSIBILITY OF SUCH DAMAGES.
547
+
548
+ 17. Interpretation of Sections 15 and 16.
549
+
550
+ If the disclaimer of warranty and limitation of liability provided above
551
+ cannot be given local legal effect according to their terms, reviewing
552
+ courts shall apply local law that most closely approximates an absolute
553
+ waiver of all civil liability in connection with the Program, unless a
554
+ warranty or assumption of liability accompanies a copy of the Program in
555
+ return for a fee.
556
+
557
+ END OF TERMS AND CONDITIONS
@@ -0,0 +1,9 @@
1
+ Metadata-Version: 2.5
2
+ Name: auryn-http
3
+ Version: 0.1.0
4
+ Summary: Language-agnostic HTTP call<->endpoint stitch for Auryn (ADR 0006): a post-ingestion hook that resolves route-keyed APIEndpoint placeholders (emitted by any caller language) to their handler Methods across the shared multi-repo graph, by route+verb. Order-independent, 1-to-many, provenance-scoped. Depends only on auryn-core.
5
+ Author-email: Roi Lipman <roi.lipman@falkordb.com>
6
+ License: SSPL-1.0
7
+ License-File: LICENSE
8
+ Requires-Python: >=3.12
9
+ Requires-Dist: auryn-core
@@ -0,0 +1,25 @@
1
+ [project]
2
+ name = "auryn-http"
3
+ version = "0.1.0"
4
+ description = "Language-agnostic HTTP call<->endpoint stitch for Auryn (ADR 0006): a post-ingestion hook that resolves route-keyed APIEndpoint placeholders (emitted by any caller language) to their handler Methods across the shared multi-repo graph, by route+verb. Order-independent, 1-to-many, provenance-scoped. Depends only on auryn-core."
5
+ authors = [{ name = "Roi Lipman", email = "roi.lipman@falkordb.com" }]
6
+ requires-python = ">=3.12"
7
+ license = { text = "SSPL-1.0" }
8
+ dependencies = [
9
+ # Reads/writes the finished graph via GraphWriter; matches routes with plain graph queries.
10
+ # No language-extraction engines -- it joins facts the language parsers already emitted.
11
+ "auryn-core",
12
+ ]
13
+
14
+ # A post-ingestion hook, registered in the `auryn.enrichments` group so the ingest endpoint
15
+ # runs it after every language pass (full ingest AND incremental resync). See core/registry.py;
16
+ # toggle with `auryn hooks enable/disable http-endpoints`.
17
+ [project.entry-points."auryn.enrichments"]
18
+ http = "auryn.ingestors.http"
19
+
20
+ [build-system]
21
+ requires = ["hatchling"]
22
+ build-backend = "hatchling.build"
23
+
24
+ [tool.hatch.build.targets.wheel]
25
+ packages = ["src/auryn"]
@@ -0,0 +1,16 @@
1
+ """The HTTP call<->endpoint stitch -- a registered graph enrichment (post-pass), not a
2
+ BaseIngestor or a CLI command. It runs after the language ingestors (via
3
+ core.ingest.run_post_hooks, on both the full and incremental paths) and resolves route-keyed
4
+ APIEndpoint placeholders to their handler Methods across the shared graph. See stitch.py."""
5
+
6
+ from auryn.core.registry import GraphEnrichment, register_graph_enrichment
7
+ from auryn.ingestors.http.stitch import run as _run
8
+
9
+ # order=200 (> the default 100): the stitch is the RESOLVER -- it must run AFTER every endpoint-DECLARATION
10
+ # enrichment (pyframework's `python-routes`, javaframework's `java-routes`, ...) so their APIEndpoints
11
+ # already exist when it matches callers to handlers. With the default order, `http-endpoints` sorted
12
+ # alphabetically BEFORE `java-routes`/`python-routes` and ran first, so a route declared by an enrichment
13
+ # (not by a language ingestor, e.g. C#) wouldn't resolve to its callers on a fresh single-pass ingest.
14
+ register_graph_enrichment(GraphEnrichment(name="http-endpoints", run=_run, order=200))
15
+
16
+ __all__ = ["_run"]
@@ -0,0 +1,15 @@
1
+ """Graph schema the HTTP stitch touches (ADR 0006). The APIEndpoint node + EXPOSES_ENDPOINT edge
2
+ are shared with the language ingestors; declared here so the hook can ensure the route index it
3
+ seeks on exists even when it runs first."""
4
+
5
+ from __future__ import annotations
6
+
7
+ from auryn.core.graph_model import EdgeSchema, NodeSchema
8
+
9
+ NODE_SCHEMAS = [
10
+ NodeSchema(label="APIEndpoint", indexed_properties=("route",)),
11
+ ]
12
+
13
+ EDGE_SCHEMAS = [
14
+ EdgeSchema(rel_type="EXPOSES_ENDPOINT"), # handler Method -> APIEndpoint (provenance http-stitch)
15
+ ]
@@ -0,0 +1,247 @@
1
+ """HTTP call<->endpoint stitch (ADR 0006).
2
+
3
+ Callers (any language) materialize each outbound request as a route-keyed placeholder
4
+ `APIEndpoint{resolved:false, provenance:"http-derived"}` they `CALLS_API`-> . This pass resolves
5
+ each placeholder to its handler `Method`(s) across the shared multi-repo graph -- by route + verb,
6
+ never by symbol -- and links them with `EXPOSES_ENDPOINT`, so the golden path reads:
7
+
8
+ caller -CALLS_API-> APIEndpoint <-EXPOSES_ENDPOINT- handler Method
9
+
10
+ Language-agnostic: it neither knows nor cares that the caller is JS and the handler C#.
11
+ Idempotent + order-independent: it owns its layer (the `http-stitch` EXPOSES_ENDPOINT edges + the
12
+ `resolved` flag), rebuilt from the current graph each run, so JS-first vs C#-first converge and a
13
+ re-ingest self-corrects. 1-to-many is deliberate -- a route matching handlers in two repos
14
+ (monolith + platform service) links both, the capability-existence signal (doc S6.1).
15
+ """
16
+
17
+ from __future__ import annotations
18
+
19
+ import logging
20
+
21
+ from auryn.core.graph_client import GraphWriter, semantic_label
22
+ from auryn.core.graph_model import GraphEdge
23
+ from auryn.ingestors.http.schema import NODE_SCHEMAS
24
+
25
+ logger = logging.getLogger("auryn.http")
26
+
27
+
28
+ def run(writer: GraphWriter, repo, target_sha: str) -> dict | None:
29
+ """GraphEnrichment entrypoint. `repo`/`target_sha` are unused -- the stitch reads only the
30
+ finished graph. Returns None when there are no HTTP-derived placeholders to resolve."""
31
+ return stitch(writer)
32
+
33
+
34
+ def stitch(writer: GraphWriter) -> dict | None:
35
+ # An attribute-routed endpoint declaration and a caller that reaches the same route+verb now key
36
+ # to the SAME route-keyed APIEndpoint (core.http_seam), so they arrive already merged -- one node,
37
+ # no duplicate. This pass only has to (a) reach the endpoints that DON'T converge by id: MVC
38
+ # `/Controller/Action` conventions and `/api/x/5` -> `api/x/{id}` templates; (b) set every
39
+ # endpoint's `resolved` from whether a handler exposes it; (c) GC endpoints left with neither a
40
+ # caller nor a handler (e.g. a route deleted from the code).
41
+ if not writer.ro_query("MATCH (e:APIEndpoint) RETURN e.id LIMIT 1").result_set:
42
+ # No endpoints remain -- but if the LAST route was just removed from the code, this layer's
43
+ # EXPOSES_ENDPOINT/INVOKES edges are now stale. Returning here without clearing would leave
44
+ # them behind (traversal would still report the deleted call), so drop them before returning.
45
+ _clear_prior_layer(writer)
46
+ return None # nothing to stitch -- also guards the empty-graph "operation on empty key"
47
+
48
+ writer.setup_schema(NODE_SCHEMAS)
49
+ _clear_prior_layer(writer)
50
+
51
+ placeholders = writer.ro_query(
52
+ "MATCH (e:APIEndpoint {provenance:'http-derived'}) RETURN e.id, e.route, e.http_method"
53
+ ).result_set
54
+ real_endpoints = _real_endpoint_index(writer) # (template segs, verb, handler id, endpoint id) -- once
55
+ edges: list[GraphEdge] = []
56
+ resolved_ids: list[str] = []
57
+ ambiguous: list[str] = []
58
+ unresolved: list[str] = []
59
+ for endpoint_id, route, http_method in placeholders:
60
+ handlers = _resolve_handlers(writer, endpoint_id, route, http_method, real_endpoints)
61
+ if not handlers:
62
+ unresolved.append(route)
63
+ continue
64
+ resolved_ids.append(endpoint_id)
65
+ if len({method_id for method_id, _, _ in handlers}) > 1:
66
+ ambiguous.append(route) # matches >1 repo -> the "does this already exist as a service?" signal
67
+ for method_id, matched_endpoint_id, handler_label in handlers:
68
+ if matched_endpoint_id == endpoint_id:
69
+ # Exact-route declaration: the handler already EXPOSES this very node (that's why it
70
+ # merged). Re-adding an `http-stitch` edge would overwrite the declared edge's
71
+ # provenance, and the next run's _clear would then delete it -- so leave it alone.
72
+ continue
73
+ # A handler is a Method (C#/Java controllers) or a Function (Python FastAPI/Flask routes
74
+ # synthesized by pyframework); use its real label so the MERGE matches the right node.
75
+ edges.append(GraphEdge("EXPOSES_ENDPOINT", handler_label, {"id": method_id},
76
+ "APIEndpoint", {"id": endpoint_id}, {"provenance": "http-stitch"}))
77
+
78
+ writer.merge_edges(edges)
79
+ _recompute_resolved(writer)
80
+ invokes = _build_invokes_edges(writer)
81
+ writer.merge_edges(invokes)
82
+ orphans_removed = _gc_orphan_endpoints(writer)
83
+
84
+ report = {
85
+ "placeholders": len(placeholders),
86
+ "resolved": len(resolved_ids),
87
+ "unresolved_routes": unresolved,
88
+ "ambiguous_routes": ambiguous,
89
+ "exposes_edges": len(edges),
90
+ "invokes_edges": len(invokes),
91
+ "orphans_removed": orphans_removed,
92
+ }
93
+ logger.info("http-endpoints: %d placeholders, %d resolved, %d exposes + %d invokes edges (%d ambiguous, %d orphans GC'd)",
94
+ len(placeholders), len(resolved_ids), len(edges), len(invokes), len(ambiguous), orphans_removed)
95
+ return report
96
+
97
+
98
+ def _clear_prior_layer(writer: GraphWriter) -> None:
99
+ """Recompute-from-scratch: drop this hook's EXPOSES_ENDPOINT and INVOKES edges. A declared
100
+ (language-parser) edge has no `http-stitch` provenance and survives; `resolved` is rebuilt
101
+ afterward by _recompute_resolved, so it isn't reset here."""
102
+ writer.query("MATCH ()-[r:EXPOSES_ENDPOINT]->() WHERE r.provenance = 'http-stitch' DELETE r")
103
+ writer.query("MATCH ()-[r:INVOKES]->() WHERE r.provenance = 'http-stitch' DELETE r")
104
+
105
+
106
+ def _build_invokes_edges(writer: GraphWriter) -> list[GraphEdge]:
107
+ """A direct, traversable `caller -[:INVOKES {via:"http"}]-> handler` edge for every resolved
108
+ seam. The endpoint node forms a "V" -- the caller points INTO it (CALLS_API) and the handler
109
+ points INTO it (EXPOSES_ENDPOINT) -- so a single-direction reachability walk (who_calls upstream,
110
+ impact_of) can't make the forward-then-backward turn and dies at the boundary. This collapses
111
+ that V into one call-like edge the curated traversal tools follow, so blast radius spans repos
112
+ and languages in one query.
113
+
114
+ Read straight off the finished graph -- every (caller, handler) pair that shares a route-keyed
115
+ APIEndpoint -- so it catches BOTH stitched seams and the exact-route merges where the declaration
116
+ and the call already collapsed onto one node (there the EXPOSES edge is the language parser's, so
117
+ a placeholder-driven pass would miss it). Raw CALLS_API/EXPOSES_ENDPOINT stay (provenance + the
118
+ viewer); INVOKES is the derived convenience edge, tagged so it's never confused with an in-process
119
+ CALLS. 1-to-many preserved: a route served in two repos links the caller to each handler."""
120
+ rows = writer.ro_query(
121
+ "MATCH (caller)-[:CALLS_API]->(:APIEndpoint)<-[:EXPOSES_ENDPOINT]-(handler) "
122
+ "WHERE (caller:Function OR caller:Method) AND (handler:Function OR handler:Method) "
123
+ "AND caller.id <> handler.id "
124
+ f"RETURN DISTINCT caller.id, {semantic_label('caller')}, handler.id, {semantic_label('handler')}"
125
+ ).result_set
126
+ return [
127
+ GraphEdge("INVOKES", str(caller_label), {"id": str(caller_id)},
128
+ str(handler_label), {"id": str(handler_id)},
129
+ {"provenance": "http-stitch", "via": "http"})
130
+ for caller_id, caller_label, handler_id, handler_label in rows
131
+ ]
132
+
133
+
134
+ def _recompute_resolved(writer: GraphWriter) -> None:
135
+ """`resolved` = does any handler expose this endpoint? Recomputed over every route-keyed endpoint
136
+ (both caller placeholders and merged declarations) so the flag is a pure function of the current
137
+ graph -- independent of ingest order and of which side (call or declaration) wrote the node."""
138
+ writer.query(
139
+ "MATCH (e:APIEndpoint) WHERE e.id STARTS WITH 'extern://http/' "
140
+ "OPTIONAL MATCH ()-[x:EXPOSES_ENDPOINT]->(e) "
141
+ "WITH e, count(x) AS handlers SET e.resolved = handlers > 0"
142
+ )
143
+
144
+
145
+ def _gc_orphan_endpoints(writer: GraphWriter) -> int:
146
+ """Delete route-keyed endpoints left with neither a caller (CALLS_API) nor a handler
147
+ (EXPOSES_ENDPOINT, from any node kind). These are the residue of a removed route or a removed
148
+ call: the `extern://http/` node lives outside any single project's id-prefix, so a project resync
149
+ can't reclaim it -- this does. Scoped to `extern://http/` so it never touches a project-scoped
150
+ endpoint another ingestor owns (e.g. pyframework's `Function`-exposed routes, which that ingestor's
151
+ own resync manages). An endpoint that is merely uncalled (declared, no caller) keeps its EXPOSES
152
+ and is NOT an orphan."""
153
+ orphans = writer.ro_query(
154
+ "MATCH (e:APIEndpoint) WHERE e.id STARTS WITH 'extern://http/' "
155
+ "AND NOT ()-[:EXPOSES_ENDPOINT]->(e) AND NOT ()-[:CALLS_API]->(e) "
156
+ "RETURN e.id"
157
+ ).result_set
158
+ if orphans:
159
+ writer.query("MATCH (e:APIEndpoint) WHERE e.id IN $ids DETACH DELETE e",
160
+ {"ids": [r[0] for r in orphans]})
161
+ return len(orphans)
162
+
163
+
164
+ def _segments(route: str) -> list[str]:
165
+ return [s for s in route.lower().split("/") if s]
166
+
167
+
168
+ def _controller_action(route: str) -> tuple[str, str] | None:
169
+ """`/api/Widgets/List` -> ("widgetscontroller", "list") by the MVC `/Controller/Action`
170
+ convention (last two path segments). None if the route has fewer than two segments."""
171
+ segs = _segments(route)
172
+ if len(segs) < 2:
173
+ return None
174
+ return f"{segs[-2]}controller", segs[-1]
175
+
176
+
177
+ def _verb_compatible(call_verb: str, endpoint_verb: str) -> bool:
178
+ """A call verb matches an endpoint verb if either side is ANY (unknown / any-verb action)."""
179
+ return call_verb == "ANY" or endpoint_verb == "ANY" or call_verb == endpoint_verb
180
+
181
+
182
+ def _route_matches(call_segs: list[str], template_segs: list[str]) -> bool:
183
+ """Concrete call route vs an endpoint route template, segment-wise. A `{param}` segment
184
+ matches any single segment (`/api/widgets/5` matches `api/widgets/{id}`)."""
185
+ if len(call_segs) != len(template_segs):
186
+ return False
187
+ return all(t.startswith("{") and t.endswith("}") or c == t for c, t in zip(call_segs, template_segs))
188
+
189
+
190
+ def _real_endpoint_index(writer: GraphWriter) -> list[tuple[list[str], str, str, str, str]]:
191
+ """(template segments, verb, handler id, endpoint id, handler label) for every DECLARED endpoint,
192
+ fetched once so route-template matching is an in-memory pass, not a query per placeholder. A
193
+ declared endpoint is identified by a non-`http-stitch` EXPOSES_ENDPOINT edge (the language
194
+ parser's own), not by node provenance -- a merged exact-route node carries the caller's
195
+ `http-derived` provenance yet is still a real declaration by virtue of that edge. The handler is
196
+ a Method (C#/Java controllers) or a Function (Python FastAPI/Flask routes from pyframework), so
197
+ match both and carry the real label back for the EXPOSES edge. The endpoint id lets the caller
198
+ loop skip the exact-merge case (where the placeholder IS the declared node)."""
199
+ rows = writer.ro_query(
200
+ "MATCH (m)-[r:EXPOSES_ENDPOINT]->(real:APIEndpoint) "
201
+ "WHERE (m:Method OR m:Function) AND real.route IS NOT NULL "
202
+ "AND coalesce(r.provenance, '') <> 'http-stitch' "
203
+ f"RETURN real.route, coalesce(real.http_method, 'ANY'), m.id, real.id, {semantic_label('m')}"
204
+ ).result_set
205
+ return [(_segments(route), str(verb).upper(), mid, rid, str(lbl)) for route, verb, mid, rid, lbl in rows]
206
+
207
+
208
+ def _resolve_handlers(
209
+ writer: GraphWriter,
210
+ placeholder_id: str,
211
+ route: str,
212
+ http_method,
213
+ real_endpoints: list[tuple[list[str], str, str, str, str]],
214
+ ) -> list[tuple[str, str | None, str]]:
215
+ """(handler id, matched declared-endpoint id | None, handler label) for a route, across all repos
216
+ (1-to-many). Two strategies: the MVC `/Controller/Action` convention (the caller's own node is the
217
+ endpoint, so matched-id is None), and a verb-aware route-template match against declared endpoints
218
+ (`/api/x/5` ↔ `api/x/{id}`; matched-id is that declaration's id -- equal to `placeholder_id` only
219
+ on an exact-route merge). The label ("Method" or "Function") lets the EXPOSES edge MERGE against
220
+ the handler's real node kind."""
221
+ handlers: list[tuple[str, str | None, str]] = []
222
+ seen: set[tuple[str, str | None]] = set()
223
+
224
+ def add(method_id: str, endpoint_id: str | None, label: str) -> None:
225
+ if (method_id, endpoint_id) not in seen:
226
+ seen.add((method_id, endpoint_id))
227
+ handlers.append((method_id, endpoint_id, label))
228
+
229
+ ca = _controller_action(route)
230
+ if ca is not None:
231
+ controller_class, action = ca
232
+ rows = writer.ro_query(
233
+ "MATCH (c:Class)-[:HAS_METHOD]->(m:Method) "
234
+ "WHERE toLower(c.name) = $cc AND (toLower(m.name) = $a OR toLower(m.action_name) = $a) "
235
+ "RETURN DISTINCT m.id",
236
+ {"cc": controller_class, "a": action},
237
+ ).result_set
238
+ for r in rows:
239
+ add(r[0], None, "Method") # MVC actions are always Methods on a controller Class
240
+
241
+ call_segs = _segments(route)
242
+ call_verb = str(http_method or "ANY").upper()
243
+ for template_segs, endpoint_verb, method_id, real_id, handler_label in real_endpoints:
244
+ if _verb_compatible(call_verb, endpoint_verb) and _route_matches(call_segs, template_segs):
245
+ add(method_id, real_id, handler_label)
246
+
247
+ return handlers