fusible 0.20.5

Electronic linter: a fuse that blows to block firmware code generation
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148

//! Subcommand: `fusible init` — scaffold a complete Fusible & tscircuit project.

mod currency;
mod templates;

use std::path::{Path, PathBuf};
use std::process::Command;

use miette::Diagnostic;
use thiserror::Error;

use crate::tscircuit::bun_path;
use crate::tscircuit::detect::resolve_program;

/// Error raised when initialization cannot be completed.
#[derive(Debug, Error, Diagnostic)]
#[error("cannot initialize project: {message}")]
#[diagnostic(help("ensure you have write permissions and target files do not already exist"))]
pub struct InitError {
    message: String,
}

impl InitError {
    pub fn new(msg: impl Into<String>) -> Self {
        Self {
            message: msg.into(),
        }
    }
}

/// Scaffolds a new Fusible project and hardware workspace in the target directory.
pub fn run(
    path: Option<PathBuf>,
    name: Option<String>,
    mcu: Option<String>,
    currency: Option<String>,
    no_install: bool,
) -> Result<(), InitError> {
    let base_dir = path.unwrap_or_else(|| PathBuf::from("."));
    let currency = currency.as_deref().map(currency::parse).transpose()?;
    prepare_base_dir(&base_dir)?;

    let project_name = name.unwrap_or_else(|| default_project_name(&base_dir));
    let mcu_chip = mcu.unwrap_or_else(|| "esp32-s3".to_string());
    std::fs::write(
        base_dir.join("fusible.yml"),
        templates::manifest(&project_name, &mcu_chip),
    )
    .map_err(|e| InitError::new(format!("failed to write fusible.yml: {e}")))?;

    if let Some(currency) = currency {
        currency::write_bom(&base_dir, currency)?;
    }

    let hw_dir = base_dir.join("hardware");
    scaffold_hardware(&hw_dir, &project_name)?;

    let gitignore_path = base_dir.join(".gitignore");
    if !gitignore_path.exists() {
        let _ = std::fs::write(gitignore_path, templates::GITIGNORE);
    }

    if !no_install {
        install_hardware_deps(&hw_dir);
    }

    print_summary(&project_name);
    Ok(())
}

/// Creates `base_dir` if needed and refuses to overwrite an existing manifest.
fn prepare_base_dir(base_dir: &Path) -> Result<(), InitError> {
    if !base_dir.exists() {
        std::fs::create_dir_all(base_dir)
            .map_err(|e| InitError::new(format!("failed to create directory: {e}")))?;
    }
    if base_dir.join("fusible.yml").exists() || base_dir.join("fusible.yaml").exists() {
        return Err(InitError::new(
            "fusible.yml already exists in target directory",
        ));
    }
    Ok(())
}

/// Names the project after its directory, or `sensor-node` when that fails.
fn default_project_name(base_dir: &Path) -> String {
    base_dir
        .canonicalize()
        .ok()
        .and_then(|p| p.file_name().map(|n| n.to_string_lossy().to_string()))
        .unwrap_or_else(|| "sensor-node".to_string())
}

/// Creates the hardware workspace and its starter files.
fn scaffold_hardware(hw_dir: &Path, project_name: &str) -> Result<(), InitError> {
    std::fs::create_dir_all(hw_dir)
        .map_err(|e| InitError::new(format!("failed to create hardware directory: {e}")))?;
    write_new(
        &hw_dir.join("package.json"),
        &templates::package_json(project_name),
    )?;
    write_new(&hw_dir.join("tsconfig.json"), templates::TSCONFIG_JSON)?;
    write_new(&hw_dir.join("index.tsx"), templates::INDEX_TSX)
}

/// Prints the scaffolded tree and suggested next commands.
fn print_summary(project_name: &str) {
    println!("✨ Successfully initialized Fusible project \"{project_name}\"");
    println!("  ├── fusible.yml           (Fusible configuration & fuse contract)");
    println!("  └── hardware/");
    println!("      ├── index.tsx         (tscircuit schematic + layout design)");
    println!("      ├── package.json      (tscircuit dependencies)");
    println!("      └── tsconfig.json");
    println!();
    println!("Next steps:");
    println!("  fusible studio            Open the studio: interactive hot-reloading viewer");
    println!(
        "  fusible check             Validate electrical design rules & extract firmware pins"
    );
    println!("  fusible export --preset cad  Export KiCad project for Electrical Engineers");
    println!("  fusible add <pkg>         Install tscircuit packages or footprints");
    println!("  fusible build             Compile hardware artifacts & build firmware");
}

/// Writes `content` to `path` unless the file already exists, which it reports and keeps.
fn write_new(path: &Path, content: &str) -> Result<(), InitError> {
    if path.exists() {
        println!("↷ Keeping existing {}", path.display());
        return Ok(());
    }
    std::fs::write(path, content)
        .map_err(|e| InitError::new(format!("failed to write {}: {e}", path.display())))
}

/// Runs `install` with the first available package manager in `hw_dir`.
fn install_hardware_deps(hw_dir: &Path) {
    println!("📦 Installing hardware dependencies...");
    let bun = bun_path().unwrap_or_else(|| resolve_program("bun"));
    for runner in [bun, resolve_program("npm")] {
        let mut cmd = Command::new(runner);
        cmd.arg("install").current_dir(hw_dir);
        if let Ok(mut child) = cmd.spawn() {
            let _ = child.wait();
            return;
        }
    }
    println!("⚠️  Neither bun nor npm found; run 'fusible doctor --install' or install dependencies manually.");
}