pub mod ask;
pub mod changes;
pub mod detect_impact;
pub mod edit;
pub mod federation;
pub mod file_impact;
pub mod guidance;
pub mod host;
pub mod knowledge;
pub mod read;
pub mod read_context;
pub mod reference;
pub mod remediation;
pub mod replay;
pub mod search;
pub mod session;
pub mod source_options;
pub mod stel;
pub mod symbol;
pub mod symbol_context;
pub const API_VERSION: u32 = 1;
pub use crate::embed::SourceRuntimePhase;
pub use crate::embed::lifecycle::embed_query::{QueryClaim, QueryOperationReceipt, QueryRefusal};
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize)]
pub struct QueryPolicy {
pub allow_derived_state_preparation: bool,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QueryLimits {
pub max_results: u32,
pub max_bytes: u32,
}
#[derive(Debug, Clone, Copy, Default, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
pub struct QueryUsage {
pub rows: u64,
pub decoded_bytes: u64,
}
impl Default for QueryLimits {
fn default() -> Self {
Self {
max_results: 100,
max_bytes: 65_536,
}
}
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[serde(deny_unknown_fields)]
pub struct QuerySymbolSelector {
pub path: String,
pub name: String,
pub kind: Option<String>,
pub line: Option<u32>,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub enum QueryOperationKind {
File,
FileContext,
RepoMap,
Symbol,
InspectMatch,
Context,
References,
Dependents,
SearchSymbols,
SearchText,
SearchFiles,
SearchKnowledge,
Graph,
Syntax,
Diff,
Impact,
Explore,
Conventions,
ContextInventory,
InvestigationSuggest,
EditPlan,
Retrieve,
WhatChanged,
DiffSymbols,
DetectImpact,
Ask,
Symforge,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
#[serde(deny_unknown_fields)]
pub enum QueryRequest {
TextSearch(search::TextSearchRequest),
SymbolSearch(search::SymbolSearchRequest),
FileSearch(search::FileSearchRequest),
SearchKnowledge(knowledge::search::SearchKnowledgeRequest),
FileContent(read::FileContentRequest),
RepoMap(read_context::RepoMapRequest),
FileContext(read_context::FileContextRequest),
SourcePage(read::SourcePageRequest),
SymbolRead(symbol::SymbolReadRequest),
SymbolContext(symbol_context::SymbolContextRequest),
InspectMatch(symbol::InspectMatchRequest),
ReferenceSearch(reference::ReferenceSearchRequest),
DependentSearch(reference::DependentSearchRequest),
File {
path: String,
start_line: Option<u32>,
end_line: Option<u32>,
},
Symbol {
selector: QuerySymbolSelector,
},
Context {
selector: QuerySymbolSelector,
},
References {
name: String,
target: Option<QuerySymbolSelector>,
kind: Option<String>,
include_tests: bool,
},
Dependents {
path: String,
},
SearchSymbols {
query: Option<String>,
path_prefix: Option<String>,
kind: Option<String>,
include_tests: bool,
},
SearchText {
query: String,
path_prefix: Option<String>,
regex: bool,
case_sensitive: bool,
include_tests: bool,
},
SearchFiles {
query: String,
path_prefix: Option<String>,
include_tests: bool,
},
Graph {
path_prefix: Option<String>,
offset: u64,
expected_publication: Option<String>,
},
Syntax {
path: String,
},
Diff {
path: String,
from_ref: String,
to_ref: Option<String>,
},
Impact {
path: String,
base_ref: String,
},
FileImpact(file_impact::FileImpactRequest),
Explore(guidance::ExploreRequest),
Conventions,
ContextInventory,
InvestigationSuggest {
focus: Option<String>,
},
EditPlan {
target: String,
},
Retrieve {
handle: String,
offset: u64,
},
WhatChanged(changes::WhatChangedRequest),
DiffSymbols(changes::DiffSymbolsRequest),
DetectImpact(detect_impact::DetectImpactRequest),
Ask(ask::AskRequest),
Symforge(stel::StelRequest),
}
impl QueryRequest {
pub(crate) fn freshen_paths(&self) -> Vec<&str> {
match self {
Self::FileContent(input) => vec![&input.path],
Self::SourcePage(input) => vec![&input.path],
Self::FileContext(input) => vec![&input.path],
Self::SymbolContext(input) => input
.path
.as_deref()
.or(input.file.as_deref())
.into_iter()
.collect(),
Self::Syntax { path } => vec![path],
Self::InspectMatch(input) => vec![&input.path],
Self::SymbolRead(input) => match &input.targets {
Some(targets) => {
let mut paths: Vec<&str> =
targets.iter().map(|target| target.path.as_str()).collect();
paths.sort_unstable();
paths.dedup();
paths
}
None => Some(input.path.as_str())
.filter(|path| !path.trim().is_empty())
.into_iter()
.collect(),
},
_ => Vec::new(),
}
}
pub(crate) fn answer_scope(&self) -> Option<Option<&str>> {
match self {
Self::TextSearch(input) => Some(input.path_prefix.as_deref()),
Self::SymbolSearch(input) => Some(input.path_prefix.as_deref()),
Self::FileSearch(input) => Some(input.path_prefix.as_deref()),
Self::ReferenceSearch(_)
| Self::SymbolContext(_)
| Self::DependentSearch(_)
| Self::Explore(_) => Some(None),
Self::WhatChanged(input)
if input.since.is_some()
&& input.git_ref.is_none()
&& input.uncommitted != Some(true) =>
{
Some(input.path_prefix.as_deref())
}
_ => None,
}
}
pub fn operation(&self) -> QueryOperationKind {
match self {
Self::TextSearch(_) => QueryOperationKind::SearchText,
Self::SymbolSearch(_) => QueryOperationKind::SearchSymbols,
Self::FileSearch(_) => QueryOperationKind::SearchFiles,
Self::SearchKnowledge(_) => QueryOperationKind::SearchKnowledge,
Self::FileContent(_) | Self::SourcePage(_) => QueryOperationKind::File,
Self::RepoMap(_) => QueryOperationKind::RepoMap,
Self::FileContext(_) => QueryOperationKind::FileContext,
Self::SymbolRead(_) => QueryOperationKind::Symbol,
Self::SymbolContext(_) => QueryOperationKind::Context,
Self::InspectMatch(_) => QueryOperationKind::InspectMatch,
Self::ReferenceSearch(_) => QueryOperationKind::References,
Self::DependentSearch(_) => QueryOperationKind::Dependents,
Self::File { .. } => QueryOperationKind::File,
Self::Symbol { .. } => QueryOperationKind::Symbol,
Self::Context { .. } => QueryOperationKind::Context,
Self::References { .. } => QueryOperationKind::References,
Self::Dependents { .. } => QueryOperationKind::Dependents,
Self::SearchSymbols { .. } => QueryOperationKind::SearchSymbols,
Self::SearchText { .. } => QueryOperationKind::SearchText,
Self::SearchFiles { .. } => QueryOperationKind::SearchFiles,
Self::Graph { .. } => QueryOperationKind::Graph,
Self::Syntax { .. } => QueryOperationKind::Syntax,
Self::Diff { .. } => QueryOperationKind::Diff,
Self::Impact { .. } | Self::FileImpact(_) => QueryOperationKind::Impact,
Self::Explore(_) => QueryOperationKind::Explore,
Self::Conventions => QueryOperationKind::Conventions,
Self::ContextInventory => QueryOperationKind::ContextInventory,
Self::InvestigationSuggest { .. } => QueryOperationKind::InvestigationSuggest,
Self::EditPlan { .. } => QueryOperationKind::EditPlan,
Self::Retrieve { .. } => QueryOperationKind::Retrieve,
Self::WhatChanged(_) => QueryOperationKind::WhatChanged,
Self::DiffSymbols(_) => QueryOperationKind::DiffSymbols,
Self::DetectImpact(_) => QueryOperationKind::DetectImpact,
Self::Ask(_) => QueryOperationKind::Ask,
Self::Symforge(_) => QueryOperationKind::Symforge,
}
}
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub enum QueryRefusalKind {
InvalidRequest,
UnsupportedOption,
SourceUnavailable,
AdmissionUnavailable,
NotFound,
AmbiguousSymbol,
StalePublication,
InvalidSpan,
BudgetTooSmall,
GitUnavailable,
Cancelled,
DeadlineExceeded,
SessionRequired,
ForeignSession,
StaleHandle,
GraphPublicationLeaseExpired,
PolicyMismatch,
OutputAdmissionRejected,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QueryFile {
pub path: String,
pub language: String,
pub content_hash: Option<String>,
pub parse_status: String,
pub is_test: bool,
pub is_generated: bool,
pub is_vendor: bool,
pub symbol_count: u32,
pub reference_count: u32,
pub byte_len: Option<u64>,
pub source: Option<Vec<u8>>,
pub source_byte_start: u64,
pub source_byte_end: u64,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QuerySymbol {
pub identity: String,
pub path: String,
pub symbol_index: u32,
pub name: String,
pub kind: String,
pub depth: u32,
pub start_line: u32,
pub end_line: u32,
pub byte_start: u64,
pub byte_end: u64,
pub source: Option<Vec<u8>>,
pub source_byte_start: u64,
pub source_byte_end: u64,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub doc_byte_start: Option<u64>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub doc_byte_end: Option<u64>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QueryReference {
pub path: String,
pub reference_index: u32,
pub name: String,
pub qualified_name: Option<String>,
pub kind: String,
pub start_line: u32,
pub end_line: u32,
pub byte_start: u64,
pub byte_end: u64,
pub enclosing_symbol_index: Option<u32>,
pub enclosing_symbol_identity: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QueryTextMatch {
pub path: String,
pub line: u32,
pub byte_start: u64,
pub byte_end: u64,
pub preview: String,
pub enclosing_symbol: Option<QuerySymbol>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QueryGraph {
pub files: Vec<QueryFile>,
pub symbols: Vec<QuerySymbol>,
pub references: Vec<QueryReference>,
pub next_offset: Option<u64>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QueryContext {
pub symbol: QuerySymbol,
pub callers: Vec<QueryReference>,
pub callees: Vec<QueryReference>,
pub type_usages: Vec<QueryReference>,
pub dependencies: Vec<QuerySymbol>,
pub unresolved_same_name_member_calls: Vec<QueryReference>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QuerySyntax {
pub path: String,
pub content_hash: String,
pub valid: bool,
pub parse_status: String,
pub diagnostic: Option<String>,
pub line: Option<u32>,
pub column: Option<u32>,
#[serde(default = "published_generation")]
pub authority: read::ReadAuthority,
#[serde(default)]
pub rendered: String,
}
fn published_generation() -> read::ReadAuthority {
read::ReadAuthority::PublishedGeneration
}
#[derive(Debug, Clone, PartialEq, Eq)]
#[non_exhaustive]
pub struct DiskSyntaxObservation {
pub syntax: QuerySyntax,
pub source_phase: crate::embed::SourceRuntimePhase,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QuerySymbolChange {
pub name: String,
pub kind: String,
pub occurrence: u32,
pub change: String,
pub before_hash: Option<String>,
pub after_hash: Option<String>,
pub before_line: Option<u32>,
pub after_line: Option<u32>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub before_signature: Option<String>,
#[serde(default, skip_serializing_if = "Option::is_none")]
pub after_signature: Option<String>,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QuerySymbolDiff {
pub path: String,
pub from_commit: String,
pub to_commit: Option<String>,
pub changes: Vec<QuerySymbolChange>,
pub partial: bool,
}
#[derive(Debug, Clone, PartialEq, Eq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
pub struct QueryObservation {
pub kind: String,
pub identity: String,
pub content_hash: String,
}
#[derive(Debug, Clone, PartialEq, serde::Serialize, serde::Deserialize)]
#[non_exhaustive]
#[allow(clippy::large_enum_variant)]
pub enum QueryOutput {
TextSearch(search::TextSearchResult),
SymbolSearch(search::SymbolSearchResult),
FileSearch(search::FileSearchResult),
SearchKnowledge(knowledge::search::SearchKnowledgeResult),
FileContent(read::FileContent),
RepoMap(read_context::RepoMapResult),
FileContext(read_context::FileContextResult),
SymbolRead(symbol::SymbolReadResult),
SymbolContext(symbol_context::SymbolContextResult),
InspectMatch(symbol::InspectMatchResult),
ReferenceSearch(reference::ReferenceSearchResult),
DependentSearch(reference::DependentSearchResult),
SourcePage(read::SourcePage),
FileReadEstimate(read::FileReadEstimate),
SearchEstimate(search::SearchEstimate),
ContextInventory(session::ContextInventory),
InvestigationSuggestion(session::InvestigationSuggestion),
RetrievedOutput(session::RetrievedOutput),
Exploration(guidance::Exploration),
Conventions(guidance::Conventions),
EditPlan(guidance::EditPlanGuidance),
File {
file: QueryFile,
symbols: Vec<QuerySymbol>,
imports: Vec<QueryReference>,
},
Symbol(QuerySymbol),
Context(QueryContext),
References(Vec<QueryReference>),
Dependents(Vec<QueryReference>),
Symbols(Vec<QuerySymbol>),
Text(Vec<QueryTextMatch>),
Files(Vec<QueryFile>),
Graph(QueryGraph),
Syntax(QuerySyntax),
Diff(QuerySymbolDiff),
Impact {
diff: QuerySymbolDiff,
dependents: Vec<QueryReference>,
},
FileImpact(file_impact::FileImpactReport),
WhatChanged(changes::WhatChangedResult),
DiffSymbols(changes::DiffSymbolsResult),
DetectImpact(detect_impact::DetectImpactResult),
Ask(ask::AskResult),
Symforge(stel::SymforgeAnswer),
}