Struct IndexStatus 

pub struct IndexStatus {

    pub exists: bool,
    pub path: Option<String>,
    pub created_at: Option<String>,
    pub age_seconds: Option<u64>,
    pub symbol_count: Option<usize>,
    pub file_count: Option<usize>,
    pub languages: Option<Vec<String>>,
    pub supports_fuzzy: bool,
    pub supports_relations: bool,
    pub cross_language_relation_count: Option<usize>,
    pub symbol_counts_by_kind: Option<HashMap<String, usize>>,
    pub file_counts_by_language: Option<HashMap<String, usize>>,
    pub relation_counts_by_pair: Option<HashMap<String, usize>>,
    pub stale: Option<bool>,
    pub building: Option<bool>,
    pub build_age_seconds: Option<u64>,
    pub aggregate: Option<WorkspaceIndexStatus>,
    pub partial: Option<bool>,
}

Index status information for programmatic consumers

Fields

exists: bool

Whether an index exists

path: Option<String>

Path to the index directory

created_at: Option<String>

When the index was created (ISO 8601 format)

age_seconds: Option<u64>

Age of the index in seconds

symbol_count: Option<usize>

Total number of symbols indexed

file_count: Option<usize>

Number of files indexed

languages: Option<Vec<String>>

Languages found in the index

supports_fuzzy: bool

Whether fuzzy search is supported

supports_relations: bool

Whether relation queries are supported

cross_language_relation_count: Option<usize>

Total count of cross-language relations

symbol_counts_by_kind: Option<HashMap<String, usize>>

Node counts grouped by kind (e.g., {“function”: 25669, “class”: 332}) Used for tree view grouping in VSCode extension

file_counts_by_language: Option<HashMap<String, usize>>

File counts grouped by language (e.g., {“rust”: 1245, “javascript”: 523}) Used for tree view grouping in VSCode extension

relation_counts_by_pair: Option<HashMap<String, usize>>

Relation counts grouped by language pair (e.g., {“go→javascript”: 45}) Used for tree view grouping in VSCode extension

stale: Option<bool>

Whether index is considered stale (>24 hours old)

building: Option<bool>

Whether an index build is currently in progress (lock file exists)

build_age_seconds: Option<u64>

Age of the lock file in seconds (if build is in progress)

aggregate: Option<WorkspaceIndexStatus>

Aggregate WorkspaceIndexStatus for the workspace this path belongs to.

Set only by Self::aggregate. The §1.4 contract for the member-folder branch of sqry/indexStatus: when path classifies as Member, the response carries the full per-source-root status vector, the missing_count / building_count / ok_count / error_count summary counters, and the generated_at timestamp. Source / Excluded / Unknown branches leave this field None so the wire shape stays backwards-compatible.

partial: Option<bool>

true when this status is a partial aggregate — at least one source root is missing or error, so the workspace is not fully indexed. Set only on the Self::aggregate path.

Distinct from Self::stale (which carries the >24h freshness bit on per-source-root responses); the two flags coexist in the wire shape so consumers can disambiguate “old snapshot” from “incomplete workspace”.

Implementations

impl IndexStatus

pub fn not_found() -> Self

Create a new index status for non-existent index

pub fn excluded() -> Self

Create an index status indicating the path is explicitly excluded from the logical workspace (per LogicalWorkspace::classify returning Classification::Excluded).

Wire shape mirrors Self::not_found (no graph data) but the path field carries the canonical excluded path so the client can disambiguate “outside workspace” from “inside but excluded”. Callers must populate path post-construction when context is available.

Examples

use sqry_core::json_response::IndexStatus;
let status = IndexStatus::excluded();
assert!(!status.exists);

pub fn aggregate(member_path: PathBuf, aggregate: WorkspaceIndexStatus) -> Self

Create an IndexStatus carrying the full aggregate crate::workspace::WorkspaceIndexStatus for a workspace that the requested path belongs to as a member folder (§1.4 of the implementation plan, acceptance criterion 3).

Member folders never own a snapshot themselves; they route through their workspace’s source roots. The response therefore preserves the full per-source-root detail (source_root_statuses, missing_count, building_count, ok_count, error_count, generated_at) inside the Self::aggregate field, and surfaces convenience summary projections through the existing Self::exists, Self::building, and Self::age_seconds scalars so simple consumers (e.g. --json formatters) can render a one-line summary without re-walking the vector.

• Self::exists is true iff every source root reports Ok (no missing, no errors). This mirrors the §1.4 contract that a member folder “is indexed” only when the workspace as a whole is.
• Self::path is set to the canonical member-folder path the caller supplied; consumers can disambiguate from Self::not_found (which omits path).
• Self::building is set when any source root has a build-lock present.
• Self::partial is set when any source root is Missing or Error, signalling that the aggregate is incomplete.
• Self::age_seconds is computed against aggregate.generated_at when at least one source root reports Ok.

Examples

use std::path::PathBuf;
use sqry_core::json_response::IndexStatus;
use sqry_core::workspace::WorkspaceIndexStatus;
let aggregate = WorkspaceIndexStatus::from_source_root_statuses(Vec::new());
let status = IndexStatus::aggregate(PathBuf::from("/tmp/member"), aggregate);
assert_eq!(status.path.as_deref(), Some("/tmp/member"));

pub fn from_index( path: String, created_at: String, age_seconds: u64, ) -> IndexStatusBuilder

Create index status from metadata (builder pattern to avoid too many args)

Trait Implementations

impl Clone for IndexStatus

fn clone(&self) -> IndexStatus

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for IndexStatus

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Serialize for IndexStatus

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.