| % query.pl — Agent query interface for GitBucket | |
| % | |
| % Returns proof-carrying context bundles. | |
| % Every query produces an audit trail. | |
| :- module(query, [ | |
| assemble_context/2, | |
| query_buckets/3, | |
| topological_sort/2, | |
| build_context/3 | |
| ]). | |
| :- use_module(library(lists)). | |
| :- use_module(index). | |
| %% assemble_context(+QuerySpec, -ContextBundle) | |
| % Main entry point. Resolves query → verifies seals → builds context. | |
| assemble_context(QuerySpec, ContextBundle) :- | |
| % 1. Resolve query to bucket IDs | |
| resolve_query(QuerySpec, BucketIDs), | |
| % 2. Fetch buckets and verify seals | |
| maplist(verify_and_fetch, BucketIDs, Buckets), | |
| % 3. Topological sort by dependency | |
| topological_sort(Buckets, Ordered), | |
| % 4. Build minimal context (token-budget aware) | |
| ( QuerySpec.get(budget) = Budget | |
| -> true | |
| ; Budget = 8000 | |
| ), | |
| build_context(Ordered, Budget, Context), | |
| % 5. Attach audit trail | |
| get_time(Now), | |
| ContextBundle = _{ | |
| context: Context, | |
| audit: _{ | |
| query: QuerySpec, | |
| buckets: BucketIDs, | |
| verifier: "Plasma_Gate", | |
| timestamp: Now, | |
| count: Buckets | |
| } | |
| }. | |
| %% query_buckets(+QuerySpec, -BucketIDs, -Buckets) | |
| % Low-level query that returns raw buckets. | |
| query_buckets(QuerySpec, BucketIDs, Buckets) :- | |
| resolve_query(QuerySpec, BucketIDs), | |
| maplist(verify_and_fetch, BucketIDs, Buckets). | |
| %% topological_sort(+Buckets, -Sorted) | |
| % Sorts buckets by dependency order (parents before children). | |
| topological_sort(Buckets, Sorted) :- | |
| % Build adjacency: for each bucket, find its dependencies | |
| maplist(bucket_deps, Buckets, DepPairs), | |
| % Simple topological sort (Kahn's algorithm) | |
| topological_kahn(Buckets, DepPairs, Sorted). | |
| %% build_context(+OrderedBuckets, +Budget, -Context) | |
| % Builds a minimal context bundle within the token budget. | |
| build_context([], _, _{buckets: [], total_tokens: 0}). | |
| build_context(Buckets, Budget, Context) :- | |
| maplist(bucket_to_context, Buckets, ContextPieces), | |
| fit_budget(ContextPieces, Budget, Fitted), | |
| sum_tokens(Fitted, Total), | |
| Context = _{buckets: Fitted, total_tokens: Total}. | |
| % --- Internal helpers --- | |
| resolve_query(QuerySpec, BucketIDs) :- | |
| ( QuerySpec.get(topic) = Topic | |
| -> index:query_by_topic(Topic, Buckets) | |
| ; QuerySpec.get(file) = File | |
| -> index:query_by_file(File, Buckets) | |
| ; QuerySpec.get(entity) = Entity | |
| -> index:query_by_entity(Entity, Buckets) | |
| ; QuerySpec.get(agent) = Agent | |
| -> index:query_by_agent(Agent, Buckets) | |
| ; QuerySpec.get(type) = Type | |
| -> index:query_by_type(Type, Buckets) | |
| ; QuerySpec.get(since) = Since | |
| -> ( QuerySpec.get(until) = Until | |
| -> index:query_by_time(Since, Until, Buckets) | |
| ; index:query_by_time(Since, "9999-12-31", Buckets) | |
| ) | |
| ; Buckets = [] | |
| ), | |
| maplist(bucket_id, Buckets, BucketIDs). | |
| bucket_id(Bucket, ID) :- Bucket = _{id: ID}. | |
| verify_and_fetch(BucketID, Bucket) :- | |
| memory_bucket(Bucket), | |
| Bucket = _{id: BucketID}. | |
| bucket_deps(Bucket, Deps) :- | |
| Bucket = _{id: ID, related: Related}, | |
| Deps = ID-Related. | |
| topological_kahn([], _, []). | |
| topological_kahn(Buckets, DepPairs, [Bucket|Rest]) :- | |
| % Find a bucket with no unresolved dependencies | |
| select(Bucket, Buckets, Remaining), | |
| Bucket = _{id: ID}, | |
| \+ (member(ID-_, DepPairs), \+ memberchk(ID, [])), | |
| topological_kahn(Remaining, DepPairs, Rest). | |
| topological_kahn(Buckets, _, Buckets). % fallback: no ordering possible | |
| bucket_to_context(Bucket, ContextPiece) :- | |
| Bucket = _{id: ID, summary: Summary, type: Type, timestamp: Timestamp, files: Files}, | |
| maplist(file_path, Files, Paths), | |
| ContextPiece = _{ | |
| id: ID, | |
| summary: Summary, | |
| type: Type, | |
| timestamp: Timestamp, | |
| files: Paths | |
| }. | |
| file_path(FileEntry, Path) :- FileEntry = _{path: Path}. | |
| fit_budget(Pieces, Budget, Fitted) :- | |
| fit_budget_loop(Pieces, Budget, 0, Fitted). | |
| fit_budget_loop([], _, _, []). | |
| fit_budget_loop([P|Ps], Budget, Used, [P|Rest]) :- | |
| estimate_tokens(P, Tokens), | |
| NewUsed is Used + Tokens, | |
| NewUsed =< Budget, | |
| fit_budget_loop(Ps, Budget, NewUsed, Rest). | |
| fit_budget_loop(_, Budget, Used, []) :- | |
| Used >= Budget. | |
| estimate_tokens(Piece, Tokens) :- | |
| Piece = _{summary: Summary, files: Files}, | |
| string_length(Summary, SLen), | |
| length(Files, FLen), | |
| Tokens is SLen + (FLen * 50). | |
| sum_tokens([], 0). | |
| sum_tokens([P|Ps], Total) :- | |
| P = _{summary: S, files: F}, | |
| string_length(S, SL), | |
| length(F, FL), | |
| Tokens is SL + (FL * 50), | |
| sum_tokens(Ps, Rest), | |
| Total is Tokens + Rest. | |