electron-cli 0.3.0-alpha.1 → 0.3.0-alpha.3

package/Cargo.lock

@@ -115,7 +115,7 @@ checksum = "1d07550c9036bf2ae0c684c4297d503f838287c83c53686d05370d0e139ae570"
 
 [[package]]
 name = "electron-cli"
-version = "0.3.0-alpha.1"
+version = "0.3.0-alpha.3"
 dependencies = [
  "anyhow",
  "camino",

package/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "electron-cli"
-version = "0.3.0-alpha.1"
+version = "0.3.0-alpha.3"
 edition = "2021"
 description = "Experimental Rust CLI for Electron project diagnostics and workflow automation"
 license = "MIT"

package/README.md

@@ -6,7 +6,7 @@ This is an independent learning project. It is not affiliated with Electron, Ele
 
 ## Status
 
-This repository is intentionally small and public-learning friendly. The first useful surface area is inspection and diagnostics, because those commands are valuable for humans and easy for agents to consume safely.
+This repository is intentionally small and public-learning friendly. The first useful surface area is inspection and diagnostics, because those commands are valuable for humans and easy for agents to consume safely. The next surface area is a Rust-owned version of the main Electron Forge flow: initialize, start, package, make, and eventually publish.
 
 Current commands:
 
@@ -14,28 +14,40 @@ Current commands:
 electron-cli inspect
 electron-cli doctor
 electron-cli plan
+electron-cli init my-app
+electron-cli start
+electron-cli package
 electron-cli inspect --json
 electron-cli doctor --json
 electron-cli plan --json
+electron-cli init my-app --dry-run --json
+electron-cli start --dry-run --json
+electron-cli package --dry-run --json
 ```
 
 Planned commands:
 
 ```sh
-electron-cli dev
-electron-cli init
-electron-cli package
 electron-cli make
+electron-cli publish
 ```
 
-The planned workflow commands may start by wrapping Electron Forge or other established tools. Rust-native implementations can replace narrow pieces over time when there is a clear reason.
+The default `init` template is `minimal`, a built-in starter written by this project. Non-native template names are still passed to `create-electron-app` as an escape hatch while this project grows.
+
+The Rust-native flow currently owns:
+
+- `init --template minimal`: writes a local Electron starter without Electron Forge.
+- `start`: launches the installed Electron runtime directly.
+- `package`: copies the installed Electron runtime and app files into a local app bundle for the current platform and architecture. The first package pass supports apps without production `dependencies`; dependency pruning and bundled runtime dependencies are still TODO.
+
+`make` and `publish` are not implemented yet. They are the next pieces of the Forge lifecycle to replace.
 
 ## Install
 
 During the experimental phase, the npm package downloads a prebuilt binary from GitHub Releases when one is available. If a prebuilt binary is not available for your platform, it falls back to running from Rust source.
 
 ```sh
-npm install -g electron-cli
+npm install -g electron-cli@alpha
 electron-cli doctor
 ```
 
@@ -59,6 +71,9 @@ Or use Cargo directly:
 ```sh
 cargo run -- doctor
 cargo run -- inspect --json
+cargo run -- init my-app
+cargo run -- start --dry-run
+cargo run -- package --dry-run
 ```
 
 ## Design Goals
@@ -66,7 +81,7 @@ cargo run -- inspect --json
 - Learn Rust through a real developer tool.
 - Make Electron project state easy to inspect.
 - Prefer structured output for agentic workflows.
-- Wrap proven ecosystem tools before replacing them.
+- Replace the main Forge-style app flow with narrow Rust-owned pieces.
 - Keep the project clearly independent and experimental.
 
 ## Non-Goals
@@ -77,8 +92,11 @@ cargo run -- inspect --json
 
 ## JSON Output
 
-Both initial commands support `--json` so agents and scripts can consume project state without scraping terminal output.
+The inspection and planning commands support `--json` so agents and scripts can consume project state without scraping terminal output.
 `plan` is designed around that workflow: it recommends stable commands and reports missing project conventions as structured data.
+`init --dry-run --json` shows whether the CLI will write native template files or delegate to `create-electron-app`.
+`start --dry-run --json` shows the Electron executable that will be launched.
+`package --dry-run --json` shows the runtime and app file copy plan.
 
 ```sh
 electron-cli plan --json

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electron-cli",
-  "version": "0.3.0-alpha.1",
+  "version": "0.3.0-alpha.3",
   "description": "Experimental Rust CLI for Electron project diagnostics and workflow automation",
   "license": "MIT",
   "repository": {
@@ -18,6 +18,7 @@
     "bin/electron-cli.js",
     "scripts",
     "src",
+    "templates",
     "tests",
     "Cargo.toml",
     "Cargo.lock",

package/src/cli.rs

@@ -1,6 +1,6 @@
 use std::path::PathBuf;
 
-use clap::{Args, Parser, Subcommand};
+use clap::{Args, Parser, Subcommand, ValueEnum};
 
 #[derive(Debug, Parser)]
 #[command(
@@ -18,10 +18,16 @@ pub struct Cli {
 pub enum Commands {
     /// Check whether the current project looks ready for Electron development.
     Doctor(CommandArgs),
+    /// Bootstrap a new Electron app.
+    Init(InitArgs),
     /// Print a structured snapshot of the current JavaScript/Electron project.
     Inspect(CommandArgs),
+    /// Create a local Electron application bundle without Electron Forge.
+    Package(PackageArgs),
     /// Recommend next commands and risks from the project snapshot.
     Plan(CommandArgs),
+    /// Launch the current Electron app without Electron Forge.
+    Start(StartArgs),
 }
 
 #[derive(Debug, Clone, Args)]
@@ -34,3 +40,120 @@ pub struct CommandArgs {
     #[arg(long)]
     pub json: bool,
 }
+
+#[derive(Debug, Clone, Args)]
+pub struct InitArgs {
+    /// Directory to initialize. Defaults to the current directory.
+    #[arg(default_value = ".", value_name = "DIR")]
+    pub dir: PathBuf,
+
+    /// Directory to run the create command from.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// Template to use. "minimal" is native; other names are passed to create-electron-app.
+    #[arg(long, short = 't', default_value = "minimal")]
+    pub template: String,
+
+    /// Package manager command strategy to use.
+    #[arg(long, value_enum)]
+    pub package_manager: Option<PackageManager>,
+
+    /// Set a specific Electron version, or use latest/beta/nightly.
+    #[arg(long, value_name = "VERSION")]
+    pub electron_version: Option<String>,
+
+    /// Copy template CI files when the Forge template supports them.
+    #[arg(long)]
+    pub copy_ci_files: bool,
+
+    /// Overwrite an existing target directory.
+    #[arg(long)]
+    pub force: bool,
+
+    /// Skip initializing a git repository in the created project.
+    #[arg(long)]
+    pub skip_git: bool,
+
+    /// Print the command and metadata without creating files.
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Emit machine-readable JSON.
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct StartArgs {
+    /// Project directory to launch.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// Print the launch command without starting Electron.
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Emit machine-readable JSON.
+    #[arg(long)]
+    pub json: bool,
+
+    /// Extra arguments passed to Electron after `--`.
+    #[arg(last = true, value_name = "ELECTRON_ARG")]
+    pub electron_args: Vec<String>,
+}
+
+#[derive(Debug, Clone, Args)]
+pub struct PackageArgs {
+    /// Project directory to package.
+    #[arg(long, default_value = ".", value_name = "PATH")]
+    pub cwd: PathBuf,
+
+    /// Output directory for packaged app bundles.
+    #[arg(long, default_value = "out", value_name = "PATH")]
+    pub out_dir: PathBuf,
+
+    /// Override the packaged application name.
+    #[arg(long)]
+    pub name: Option<String>,
+
+    /// Target platform label. Defaults to the current platform.
+    #[arg(long)]
+    pub platform: Option<String>,
+
+    /// Target architecture label. Defaults to the current architecture.
+    #[arg(long)]
+    pub arch: Option<String>,
+
+    /// Overwrite an existing package output directory.
+    #[arg(long)]
+    pub force: bool,
+
+    /// Print the package plan without creating files.
+    #[arg(long)]
+    pub dry_run: bool,
+
+    /// Emit machine-readable JSON.
+    #[arg(long)]
+    pub json: bool,
+}
+
+#[derive(Debug, Clone, Copy, ValueEnum)]
+#[value(rename_all = "lower")]
+pub enum PackageManager {
+    Npm,
+    Pnpm,
+    Yarn,
+    Bun,
+}
+
+impl PackageManager {
+    pub fn as_str(self) -> &'static str {
+        match self {
+            PackageManager::Npm => "npm",
+            PackageManager::Pnpm => "pnpm",
+            PackageManager::Yarn => "yarn",
+            PackageManager::Bun => "bun",
+        }
+    }
+}