submodule remove --delete; agent commits say awaiting seal (closes #164, closes #165) 284fe47d98b9

- **Added: `oxy submodule remove --delete` (#164).** It deletes the subrepo's directory too, read-only object files and all, and refuses while the subrepo has uncommitted edits (`--force` to delete them anyway); without it, removal says the directory is left and how to delete it. A directory moved by hand used to fail halfway, after the copy, on the read-only files.

- **Changed: an agent's commit says "awaiting seal", not "unsigned" (#165).** In a checkout that signs keyless under an agent grant, a change of its own author that the next push will seal shows `◌ awaiting seal` in `oxy log` and `oxy show`; "unsigned" is kept for changes nothing will sign.

    let status = repo.authenticate_change(h)?;

    let awaiting = repo

        .store()

        .get_change(h)

        .is_ok_and(|c| awaits_seal(repo, &status, &c.author));

    Ok(match status {

        SignatureStatus::Unsigned if awaiting => {

            "awaiting seal (the next push seals it under the agent's grant)".to_string()

        }

}

/// Whether an unsigned change is one the next push will seal: this

/// checkout signs keyless (an agent under a grant) and the change is its

/// configured author's (oxygen#165). Read cold, "unsigned" looks like an

/// error; it is not one until the push.

pub fn awaits_seal(repo: &Repo, status: &SignatureStatus, author: &oxy_core::hash::KeyId) -> bool {

    matches!(status, SignatureStatus::Unsigned)

        && repo.config.signer_keyless

        && repo.config.author_key == Some(*author)

/// already in hand (the caller also reads who signed, see [`via`]);

/// `awaiting` from [`awaits_seal`].

pub fn signature_mark_of(status: &SignatureStatus, awaiting: bool) -> String {

        SignatureStatus::Unsigned if awaiting => {

            ui::dim(format!("{} awaiting seal", ui::glyph("◌", "o")))

        }

        /// Delete its directory too (#164); refused while it has uncommitted edits

        #[arg(long)]

        delete: bool,

        /// With --delete: delete it even with uncommitted edits

        #[arg(long, requires = "delete")]

        force: bool,

            SubmoduleCmd::Remove {

                path,

                delete,

                force,

            } => sync::submodule_remove(&path, delete, force),

pub fn submodule_remove(path: &str, delete: bool, force: bool) -> Result<i32> {

    let dir = repo.root().join(path.trim_end_matches('/'));

    // Look before unregistering, so a refused delete changes nothing.

    if delete && dir.exists() && !force {

        if let Ok(sub) = oxy_core::repo::Repo::open(&dir) {

            let snap = sub.snapshot("oxy submodule remove --delete")?;

            if !snap.statuses.is_empty() {

                anyhow::bail!(

                    "{path} has {} with uncommitted edits; commit them in the subrepo (and push them if you want them kept), or pass --force to delete them",

                    plural(snap.statuses.len(), "file")

                );

            }

        }

    }

    if !delete {

        println!(

            "{} subrepo {} {}",

            ui::done("Removed"),

            ui::path(path),

            ui::dim("(directory left in place; commit to record the removal)")

        );

        println!(

            "  {} {}",

            ui::note(),

            ui::dim(format!(

                "to delete the directory too: oxy submodule remove {path} --delete"

            ))

        );

        return Ok(0);

    }

    if dir.exists() {

        delete_tree(&dir)?;

    }

        ui::dim("and its directory (commit to record the removal)")

}

/// Delete a directory tree that holds a repository: its object files are

/// read-only, so each is made writable first (#164).

fn delete_tree(dir: &std::path::Path) -> Result<()> {

    fn writable(p: &std::path::Path) -> std::io::Result<()> {

        let meta = std::fs::symlink_metadata(p)?;

        if meta.file_type().is_symlink() {

            return Ok(());

        }

        let mut perms = meta.permissions();

        if perms.readonly() {

            #[allow(clippy::permissions_set_readonly_false)]

            perms.set_readonly(false);

            std::fs::set_permissions(p, perms)?;

        }

        if meta.is_dir() {

            for e in std::fs::read_dir(p)? {

                writable(&e?.path())?;

            }

        }

        Ok(())

    }

    writable(dir).map_err(|e| anyhow::anyhow!("{}: {e}", dir.display()))?;

    std::fs::remove_dir_all(dir).map_err(|e| anyhow::anyhow!("{}: {e}", dir.display()))?;

    Ok(())

    author_name, awaits_seal, deps_line, deps_of, plural, short_id, signature_line,

    signature_mark_of, subject_of, via, when,

            head.push(signature_mark_of(

                &status,

                awaits_seal(&repo, &status, &c.author),

            ));