frigg 0.9.2

Frigg gives AI agents local, source-backed code search and navigation without sending whole repositories through every prompt.
Documentation 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264

//! Path-quality penalties for generic runtime docs, frontend noise, and repo metadata.
//!
//! Down-ranks generic runtime docs, frontend noise, and repo metadata that dilute witness recall.

use crate::searcher::policy::dsl::{Predicate, ScoreRule, ScoreRuleSet, apply_score_rule_sets};
use crate::searcher::policy::facts::PathQualityFacts;
use crate::searcher::policy::kernel::PolicyProgram;
use crate::searcher::policy::predicates::path_quality as pred;
use crate::searcher::policy::trace::{PolicyEffect, PolicyStage};
use crate::searcher::surfaces::HybridSourceClass;

fn examples_or_bench_penalizes_non_support_tests(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_example_or_bench_witnesses
        && ctx.class == HybridSourceClass::Tests
        && !ctx.is_example_support
        && !ctx.is_bench_support)
        .then_some(PolicyEffect::Multiply(if ctx.wants_test_witness_recall {
            0.92
        } else {
            0.68
        }))
}

fn runtime_witness_penalizes_docs(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_witnesses
        && ctx.penalize_generic_runtime_docs
        && matches!(
            ctx.class,
            HybridSourceClass::Documentation | HybridSourceClass::Readme
        ))
    .then_some(PolicyEffect::Multiply(0.48))
}

fn runtime_witness_penalizes_generic_runtime_docs(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_witnesses
        && ctx.penalize_generic_runtime_docs
        && ctx.is_generic_runtime_witness_doc)
        .then_some(PolicyEffect::Multiply(0.34))
}

fn runtime_witness_penalizes_repo_metadata(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_witnesses && ctx.is_repo_metadata && !ctx.is_python_runtime_config)
        .then_some(PolicyEffect::Multiply(0.08))
}

fn runtime_witness_penalizes_example_support(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_witnesses
        && !ctx.wants_examples
        && !ctx.wants_benchmarks
        && ctx.is_example_support)
        .then_some(PolicyEffect::Multiply(0.32))
}

fn runtime_witness_penalizes_root_repo_metadata(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_witnesses
        && ctx.is_repo_metadata
        && ctx.path_depth <= 1
        && !ctx.is_runtime_config_artifact)
        .then_some(PolicyEffect::Multiply(0.42))
}

fn runtime_witness_penalizes_root_docs_readme(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_witnesses
        && ctx.path_depth <= 1
        && matches!(
            ctx.class,
            HybridSourceClass::Documentation | HybridSourceClass::Readme
        ))
    .then_some(PolicyEffect::Multiply(0.56))
}

fn runtime_witness_penalizes_ci_workflow_noise(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_witnesses
        && ctx.is_ci_workflow
        && !ctx.wants_ci_workflow_witnesses
        && !ctx.wants_entrypoint_build_flow
        && !ctx.wants_scripts_ops_witnesses)
        .then_some(PolicyEffect::Multiply(0.08))
}

fn runtime_witness_penalizes_frontend_runtime_noise(
    ctx: &PathQualityFacts,
) -> Option<PolicyEffect> {
    (ctx.wants_runtime_witnesses
        && !ctx.wants_examples
        && !ctx.wants_benchmarks
        && ctx.is_frontend_runtime_noise)
        .then_some(PolicyEffect::Multiply(0.42))
}

fn runtime_config_penalizes_test_support(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_config_artifacts && ctx.is_test_support && !ctx.is_runtime_config_artifact)
        .then_some(PolicyEffect::Multiply(0.58))
}

fn runtime_config_penalizes_generic_runtime_docs(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_config_artifacts
        && ctx.is_generic_runtime_witness_doc
        && !ctx.is_runtime_config_artifact)
        .then_some(PolicyEffect::Multiply(0.28))
}

fn runtime_config_penalizes_repo_metadata(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_config_artifacts && ctx.is_repo_metadata && !ctx.is_runtime_config_artifact)
        .then_some(PolicyEffect::Multiply(0.10))
}

fn runtime_config_penalizes_ci_workflow_noise(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_config_artifacts && ctx.is_ci_workflow && !ctx.is_runtime_config_artifact)
        .then_some(PolicyEffect::Multiply(0.08))
}

fn runtime_config_penalizes_example_support(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_runtime_config_artifacts
        && !ctx.wants_examples
        && !ctx.wants_benchmarks
        && ctx.is_example_support
        && !ctx.is_runtime_config_artifact)
        .then_some(PolicyEffect::Multiply(0.26))
}

fn entrypoint_penalizes_reference_docs(ctx: &PathQualityFacts) -> Option<PolicyEffect> {
    (ctx.wants_entrypoint_build_flow && ctx.is_entrypoint_reference_doc)
        .then_some(PolicyEffect::Multiply(0.72))
}

const RULES: &[ScoreRule<PathQualityFacts>] = &[
    ScoreRule::when(
        "examples_or_bench.penalizes_non_support_tests",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_example_or_bench_witnesses_leaf(),
            pred::class_is_tests_leaf(),
        ]),
        examples_or_bench_penalizes_non_support_tests,
    ),
    ScoreRule::when(
        "runtime_witness.penalizes_docs",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_witnesses_leaf(),
            pred::penalize_generic_runtime_docs_leaf(),
        ]),
        runtime_witness_penalizes_docs,
    ),
    ScoreRule::when(
        "runtime_witness.penalizes_generic_runtime_docs",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_witnesses_leaf(),
            pred::penalize_generic_runtime_docs_leaf(),
            pred::is_generic_runtime_witness_doc_leaf(),
        ]),
        runtime_witness_penalizes_generic_runtime_docs,
    ),
    ScoreRule::when(
        "runtime_witness.penalizes_repo_metadata",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_witnesses_leaf(),
            pred::is_repo_metadata_leaf(),
        ]),
        runtime_witness_penalizes_repo_metadata,
    ),
    ScoreRule::when(
        "runtime_witness.penalizes_example_support",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_witnesses_leaf(),
            pred::is_example_support_leaf(),
        ]),
        runtime_witness_penalizes_example_support,
    ),
    ScoreRule::when(
        "runtime_witness.penalizes_root_repo_metadata",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_witnesses_leaf(),
            pred::is_repo_metadata_leaf(),
        ]),
        runtime_witness_penalizes_root_repo_metadata,
    ),
    ScoreRule::when(
        "runtime_witness.penalizes_root_docs_readme",
        PolicyStage::PathQuality,
        Predicate::all(&[pred::wants_runtime_witnesses_leaf()]),
        runtime_witness_penalizes_root_docs_readme,
    ),
    ScoreRule::when(
        "runtime_witness.penalizes_ci_workflow_noise",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_witnesses_leaf(),
            pred::is_ci_workflow_leaf(),
        ]),
        runtime_witness_penalizes_ci_workflow_noise,
    ),
    ScoreRule::when(
        "runtime_witness.penalizes_frontend_runtime_noise",
        PolicyStage::PathQuality,
        Predicate::all(&[pred::wants_runtime_witnesses_leaf()]),
        runtime_witness_penalizes_frontend_runtime_noise,
    ),
    ScoreRule::when(
        "runtime_config.penalizes_test_support",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_config_artifacts_leaf(),
            pred::is_test_support_leaf(),
        ]),
        runtime_config_penalizes_test_support,
    ),
    ScoreRule::when(
        "runtime_config.penalizes_generic_runtime_docs",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_config_artifacts_leaf(),
            pred::is_generic_runtime_witness_doc_leaf(),
        ]),
        runtime_config_penalizes_generic_runtime_docs,
    ),
    ScoreRule::when(
        "runtime_config.penalizes_repo_metadata",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_config_artifacts_leaf(),
            pred::is_repo_metadata_leaf(),
        ]),
        runtime_config_penalizes_repo_metadata,
    ),
    ScoreRule::when(
        "runtime_config.penalizes_ci_workflow_noise",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_config_artifacts_leaf(),
            pred::is_ci_workflow_leaf(),
        ]),
        runtime_config_penalizes_ci_workflow_noise,
    ),
    ScoreRule::when(
        "runtime_config.penalizes_example_support",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_runtime_config_artifacts_leaf(),
            pred::is_example_support_leaf(),
        ]),
        runtime_config_penalizes_example_support,
    ),
    ScoreRule::when(
        "entrypoint.penalizes_reference_docs",
        PolicyStage::PathQuality,
        Predicate::all(&[
            pred::wants_entrypoint_build_flow_leaf(),
            pred::is_entrypoint_reference_doc_leaf(),
        ]),
        entrypoint_penalizes_reference_docs,
    ),
];

const RULE_SET: ScoreRuleSet<PathQualityFacts> = ScoreRuleSet::new(RULES);

pub(super) fn apply(program: &mut PolicyProgram, ctx: &PathQualityFacts) {
    apply_score_rule_sets(program, ctx, &[RULE_SET]);
}