rbnx/cmd/

package_new.rs

// SPDX-License-Identifier: MulanPSL-2.0
// `rbnx package-new <name>` — scaffold a new package.
//
// Two modes:
//   1. `rbnx package-new my_cam --path ./primitives/my_cam`
//       → creates directly at the given path (--type is ignored).
//   2. `rbnx package-new my_cam -t primitive`
//       → creates at `<cwd>/<role_dir>/my_cam` where role_dir is
//         derived from --type (primitives/ services/ skills/).

use anyhow::{Context, Result};
use robonix_cli::output;
use std::path::{Path, PathBuf};

/// Reject names containing path separators or traversal components.
fn validate_name(name: &str) -> Result<()> {
    if name.is_empty() {
        anyhow::bail!("name must not be empty");
    }
    if name.contains('/') || name.contains('\\') || name == ".." || name.starts_with("../") {
        anyhow::bail!("invalid name '{name}': must not contain path separators or '..' components");
    }
    Ok(())
}

pub async fn execute(name: &str, pkg_type: &str, path: Option<&Path>) -> Result<()> {
    validate_name(name)?;

    let pkg_dir: PathBuf = if let Some(p) = path {
        // --path given: use it directly, no type inference needed.
        if p.is_absolute() {
            p.to_path_buf()
        } else {
            std::env::current_dir()?.join(p)
        }
    } else {
        // No --path: derive from --type.
        let role_dir = match pkg_type {
            "primitive" => "primitives",
            "service" => "services",
            "skill" => "skills",
            other => {
                anyhow::bail!("unknown package type '{other}'; expected: primitive, service, skill")
            }
        };
        std::env::current_dir()?.join(role_dir).join(name)
    };

    if pkg_dir.exists() {
        anyhow::bail!("directory '{}' already exists", pkg_dir.display());
    }

    output::action("PackageNew", &format!("creating package '{name}'"));

    // Provider class + namespace segment for the generated skeleton.
    // `--path` mode leaves pkg_type at its clap default ("service"); fall
    // back to primitive for anything unrecognised so the skeleton is still
    // valid Python the author can edit.
    let (provider_class, ns_kind) = match pkg_type {
        "service" => ("Service", "service"),
        "skill" => ("Skill", "skill"),
        _ => ("Primitive", "primitive"),
    };

    // Create directory structure; put .gitkeep in empty dirs.
    for sub in ["scripts", "capabilities"] {
        let dir = pkg_dir.join(sub);
        std::fs::create_dir_all(&dir)
            .with_context(|| format!("failed to create {sub}/ directory"))?;
        // .gitkeep so git tracks the empty directory.
        std::fs::write(dir.join(".gitkeep"), "")
            .with_context(|| format!("failed to write {sub}/.gitkeep"))?;
    }

    // package_manifest.yaml — capabilities default to empty.
    let manifest = format!(
        r#"manifestVersion: 1

build: bash scripts/build.sh

start: bash scripts/start.sh

package:
  name: com.vendor.{name}
  version: 0.0.1
  vendor: vendor
  description: TODO
  license: Apache-2.0

capabilities: []

depends: []
"#
    );
    std::fs::write(pkg_dir.join("package_manifest.yaml"), manifest)
        .context("failed to write package_manifest.yaml")?;

    // scripts/build.sh — generate the gRPC / MCP stubs for the contracts
    // this package declares. `robonix-api` auto-discovers the output under
    // <pkg>/rbnx-build/codegen/, so nothing else is needed for a pure
    // Python package. Append your own steps (cargo, pip install -e, docker
    // build, ...) after this line if your package needs them.
    let build_sh = format!(
        r#"#!/usr/bin/env bash
set -euo pipefail
PKG="${{RBNX_PACKAGE_ROOT:-$(cd "$(dirname "$0")/.." && pwd)}}"

rbnx codegen -p "$PKG"
echo "[{name}] build done"
"#
    );
    std::fs::write(pkg_dir.join("scripts/build.sh"), build_sh)
        .context("failed to write scripts/build.sh")?;
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        std::fs::set_permissions(
            pkg_dir.join("scripts/build.sh"),
            std::fs::Permissions::from_mode(0o755),
        )?;
    }

    // scripts/start.sh — launch the provider process. `rbnx path
    // robonix-api` puts the pip-installed client library on PYTHONPATH so
    // `from robonix_api import ...` resolves. Edit the final line if your
    // entrypoint module differs, or replace it entirely (docker run, ssh,
    // a compiled binary, ...).
    let start_sh = format!(
        r#"#!/usr/bin/env bash
set -eo pipefail
PKG_ROOT="${{RBNX_PACKAGE_ROOT:-$(cd "$(dirname "$0")/.." && pwd)}}"
cd "$PKG_ROOT"

export PYTHONPATH="$(rbnx path robonix-api):$PKG_ROOT:${{PYTHONPATH:-}}"

exec python3 -m {name}.main
"#
    );
    std::fs::write(pkg_dir.join("scripts/start.sh"), start_sh)
        .context("failed to write scripts/start.sh")?;
    #[cfg(unix)]
    {
        use std::os::unix::fs::PermissionsExt;
        std::fs::set_permissions(
            pkg_dir.join("scripts/start.sh"),
            std::fs::Permissions::from_mode(0o755),
        )?;
    }

    // Remove .gitkeep from scripts/ since it now has real files.
    let _ = std::fs::remove_file(pkg_dir.join("scripts/.gitkeep"));

    // Minimal Python provider skeleton: <pkg>/<name>/{__init__.py, main.py}
    // so `python3 -m {name}.main` (from start.sh) runs out of the box. The
    // author fills in lifecycle handlers + capability declarations.
    let module_dir = pkg_dir.join(name);
    std::fs::create_dir_all(&module_dir).context("failed to create python module directory")?;
    std::fs::write(module_dir.join("__init__.py"), "").context("failed to write __init__.py")?;
    let main_py = format!(
        r#"#!/usr/bin/env python3
"""{name} — Robonix {provider_class_lower} provider."""
from robonix_api import {provider_class}, Ok

# `id` must equal this entry's `name:` in the deploy robonix_manifest.yaml.
# `namespace` groups the capabilities this provider declares.
provider = {provider_class}(id="{name}", namespace="robonix/{ns_kind}/{name}")


@provider.on_init
def init(cfg: dict):
    # TODO: initialise hardware / resources; declare capabilities to atlas.
    return Ok()


if __name__ == "__main__":
    provider.run()
"#,
        provider_class_lower = provider_class.to_lowercase(),
    );
    std::fs::write(module_dir.join("main.py"), main_py).context("failed to write main.py")?;

    // .gitignore
    std::fs::write(
        pkg_dir.join(".gitignore"),
        "rbnx-build/\n__pycache__/\n*.pyc\n.venv/\n",
    )
    .context("failed to write .gitignore")?;

    output::success(&format!(
        "Package '{name}' created at {}",
        pkg_dir.display()
    ));
    output::sub_step("package_manifest.yaml");
    output::sub_step("scripts/build.sh");
    output::sub_step("scripts/start.sh");
    output::sub_step(&format!("{name}/main.py  (provider skeleton)"));
    output::sub_step("capabilities/  (.gitkeep)");
    output::sub_step(".gitignore");

    Ok(())
}