You are an expert in writing code in many different languages. Your goal is to perform code completion for the following code, keeping in mind the rest of the code and the file meta data.
    Metadata details:
    filename: prune.rs
    path of file: ./repos/moon/crates/cli/src/commands/docker
    
    the code of the file until where you have to start completion: use super::MANIFEST_NAME;
use crate::commands::docker::scaffold::DockerManifest;
use miette::miette;
use moon::generate_project_graph;
use moon_bun_tool::BunTool;
use moon_config::PlatformType;
use moon_deno_tool::DenoTool;
use moon_node_lang::PackageJson;
use moon_node_tool::NodeTool;
use moon_platform::PlatformManager;
use moon_project_graph::ProjectGraph;
use moon_rust_tool::RustTool;
use moon_tool::DependencyManager;
use moon_workspace::Workspace;
use rustc_hash::FxHashSet;
use starbase::system;
use starbase::AppResult;
use starbase_styles::color;
use starbase_utils::fs;
use starbase_utils::json;
use std::path::Path;

pub async fn prune_bun(
    bun: &BunTool,
    workspace_root: &Path,
    project_g
    
pub async fn prune(workspace: ResourceMut<Workspace>) {
    let manifest_path = workspace.root.join(MANIFEST_NAME);

    if !manifest_path.exists() {
        return Err(miette!(
            code = "moon::docker::prune",
            "Unable to prune, docker manifest missing. Has it been scaffolded with {}?",
            color::shell("moon docker scaffold")
        ));
    }

    let project_graph = generate_project_graph(workspace).await?;
    let manifest: DockerManifest = json::read_file(manifest_path)?;
    let mut platforms = FxHashSet::<PlatformType>::default();

    for project_id in &manifest.focused_projects {
        platforms.insert(project_graph.get(project_id)?.language.clone().into());
    }

    // Do this later so we only run once for each platform instead of per project
    for platform_type in platforms {
        let platform = PlatformManager::read().get(platform_type)?;

        match platform.get_type() {
            PlatformType::Bun => {
                prune_bun(
                    platform
                        .get_tool()?
                        .as_any()
                        .downcast_ref::<BunTool>()
                        .unwrap(),
                    &workspace.root,
                    &project_graph,
                    &manifest,
                )
                .await?;
            }
            PlatformType::Deno => {
                prune_deno(
                    platform
                        .get_tool()?
                        .as_any()
                        .downcast_ref::<DenoTool>()
                        .unwrap(),
                    &workspace.root,
                    &project_graph,
                    &manifest,
                )
                .await?;
            }
            PlatformType::Node => {
                prune_node(
                    platform
                        .get_tool()?
                        .as_any()
                        .downcast_ref::<NodeTool>()
                        .unwrap(),
                    &workspace.root,
                    &project_graph,
                    &manifest,
                )
                .await?;
            }
            PlatformType::Rust => {
                prune_rust(
                    platform
                        .get_tool()?
                        .as_any()
                        .downcast_ref::<RustTool>()
                        .unwrap(),
                    &workspace.root,
                )
                .await?;
            }
            PlatformType::System | PlatformType::Unknown => {}
        }
    }
}