Enum Error 

#[non_exhaustive]
pub enum Error {
    UnknownAgent {
        name: String,
        valid: Vec<String>,
    },
    UnknownScope {
        value: String,
    },
    UnknownSkill {
        name: String,
        embedded: Vec<String>,
    },
    NoAgentSelected,
    NeedsForce(ForceRequired),
    ProjectIsHome {
        dir: PathBuf,
    },
    ProjectEscapes {
        dir: PathBuf,
        real: PathBuf,
    },
    Usage(String),
    Skills(String),
    Cancelled,
    Help,
    Io {
        context: String,
        source: Error,
    },
}

Everything this library refuses to do, and why.

Each variant a user’s own input can cause is one a front end can match on, so a mistyped flag is told apart from a disk that is full:

let (results, outcome) = skills.install(&options);
print!("{}", skill_embed::render_results(&results, options.dry_run));
if let Err(skill_embed::Error::NeedsForce(_)) = outcome {
    // tell the user to re-run with --force
}

Variants (Non-exhaustive)

Non-exhaustive enums could have additional variants added in future. Therefore, when matching against variants of non-exhaustive enums, an extra wildcard arm must be added to account for any future variants.

UnknownAgent

--agent named no agent this tool offers.

Fields

name: String

The name that was given.

valid: Vec<String>

The names that would have been accepted.

UnknownScope

--scope was neither project nor user.

Fields

value: String

The value that was given.

UnknownSkill

A named skill is not embedded.

Fields

name: String

The name that was given.

embedded: Vec<String>

The names the binary carries.

NoAgentSelected

The --agent values resolved to nothing at all.

NeedsForce(ForceRequired)

A destination held something this tool did not write, or something edited after it did.

Install leaves those skills alone and writes the rest, so the results it returns alongside this are still worth reporting.

ProjectIsHome

Project scope resolved to the home directory.

The user scope directories live there. A project installation written into them would put one project’s skills in front of every other project, and --scope user already writes there on purpose.

Fields

dir: PathBuf

The directory the search landed on.

ProjectEscapes

A project scope destination is outside the project root.

The path a project install writes to comes from the project, so a link committed at .claude/skills, or at any directory above it, aims the write and a later forced removal wherever it points. Cloning a repository and running the tool once is the whole of it. User scope and --dir are the user naming a place, and are not bounded this way.

Fields

dir: PathBuf

The destination as it was resolved.

real: PathBuf

Where it really lands.

Usage(String)

The command line could not be read.

Skills(String)

The embedded skills could not be read as skills. It is a build-time mistake rather than a runtime condition.

Cancelled

The run was cancelled through InstallOptions::cancel.

Help

Help was asked for and printed. It is not a failure.

Io

Something the file system refused.

Fields

context: String

What was being done.

source: Error

What the file system said.

Trait Implementations

impl Debug for Error

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

Formats the value using the given formatter.

impl Display for Error

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

Formats the value using the given formatter.

impl Error for Error

fn source(&self) -> Option<&(dyn Error + 'static)>

Returns the lower-level source of this error, if any.

fn description(&self) -> &str

👎Deprecated since 1.42.0:

use the Display impl or to_string()

fn cause(&self) -> Option<&dyn Error>

👎Deprecated since 1.33.0:

replaced by Error::source, which can support downcasting

fn provide<'a>(&'a self, request: &mut Request<'a>)

🔬This is a nightly-only experimental API. (error_generic_member_access)

Provides type-based access to context intended for error reports.

impl From<ForceRequired> for Error

fn from(source: ForceRequired) -> Self

Converts to this type from the input type.