Struct Skills 

pub struct Skills {
    pub skills: Vec<SkillStatus>,
    pub findings: Vec<SkillFinding>,
}

Every skill of a repository, derived, and every finding.

use majordomus_cli::evidence::Ledger;
use majordomus_cli::skill::Skills;
use majordomus_cli::synthetic::SyntheticRepository;
let repo = SyntheticRepository::small().unwrap();
let skills = Skills::build(&repo.index().unwrap(), &Ledger::empty());
assert!(skills.skill("no-such-skill").is_none());

Fields

skills: Vec<SkillStatus>

Every skill, in index order.

findings: Vec<SkillFinding>

Every finding: each skill’s, then those about no one skill (a binding to nothing).

Implementations

impl Skills

pub fn build(index: &Index, ledger: &Ledger) -> Skills

Derive every skill’s standing from the index, the evidence ledger, the tracked tests, the tracked invocation surfaces and the CI model.

use majordomus_cli::evidence::Ledger;
use majordomus_cli::skill::Skills;
use majordomus_cli::synthetic::SyntheticRepository;
let repo = SyntheticRepository::small().unwrap();
let a = Skills::build(&repo.index().unwrap(), &Ledger::empty());
let b = Skills::build(&repo.index().unwrap(), &Ledger::empty());
assert_eq!(a, b, "two reads of one tree derive the same answer");

pub fn skill(&self, id: &str) -> Option<&SkillStatus>

One skill by id, the directory name under .ai/repo/skills/; None only when the repository has no skill of that name, since one the index refused is still listed, standing invalid.

use majordomus_cli::skill::Skills;
let empty = Skills { skills: vec![], findings: vec![] };
assert!(empty.skill("implement").is_none());

pub fn failures(&self) -> usize

How many findings refuse: skills verify is valid only when this is zero. Warnings are counted apart, by Skills::warnings, and never make it invalid.

use majordomus_cli::skill::Skills;
assert_eq!(Skills { skills: vec![], findings: vec![] }.failures(), 0);

pub fn warnings(&self) -> usize

How many findings are warnings: debts a skill still owes that do not refuse the verdict, such as a partial standing. Refusals are counted by Skills::failures.

use majordomus_cli::skill::Skills;
assert_eq!(Skills { skills: vec![], findings: vec![] }.warnings(), 0);

Trait Implementations

impl Clone for Skills

fn clone(&self) -> Skills

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for Skills

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for Skills

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Eq for Skills

impl JsonSchema for Skills

fn schema_name() -> Cow<'static, str>

The name of the generated JSON Schema.

fn schema_id() -> Cow<'static, str>

Returns a string that uniquely identifies the schema produced by this type.

fn json_schema(generator: &mut SchemaGenerator) -> Schema

Generates a JSON Schema for this type.

fn inline_schema() -> bool

Whether JSON Schemas generated for this type should be included directly in parent schemas, rather than being re-used where possible using the $ref keyword.

impl PartialEq for Skills

fn eq(&self, other: &Skills) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Skills

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

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl StructuralPartialEq for Skills