electron-cli 0.2.8 → 0.3.0-alpha.1

package/src/commands/plan.rs

@@ -0,0 +1,235 @@
+use std::collections::BTreeMap;
+
+use anyhow::Result;
+use serde::Serialize;
+
+use crate::{cli::CommandArgs, output, project};
+
+#[derive(Debug, Serialize)]
+struct PlanReport {
+    project_type: ProjectType,
+    recommended_commands: BTreeMap<String, String>,
+    missing: Vec<String>,
+    risks: Vec<String>,
+    notes: Vec<String>,
+}
+
+#[derive(Debug, Serialize)]
+#[serde(rename_all = "kebab-case")]
+enum ProjectType {
+    ElectronForge,
+    Electron,
+    JavaScript,
+    Unknown,
+}
+
+pub fn run(args: CommandArgs) -> Result<()> {
+    let snapshot = project::inspect(&args.cwd)?;
+    let report = build_report(&snapshot);
+
+    if args.json {
+        output::json(&report)
+    } else {
+        println!("electron-cli plan");
+        println!();
+        println!("Project");
+        println!("  root: {}", snapshot.root);
+        match snapshot.package_label() {
+            Some(label) => println!("  package: {label}"),
+            None => println!("  package: not found"),
+        }
+        println!("  type: {}", report.project_type.as_str());
+
+        if !report.recommended_commands.is_empty() {
+            println!();
+            println!("Recommended Commands");
+            for (name, command) in &report.recommended_commands {
+                println!("  {name}: {command}");
+            }
+        }
+
+        if !report.missing.is_empty() {
+            println!();
+            println!("Missing");
+            for item in &report.missing {
+                println!("  {item}");
+            }
+        }
+
+        if !report.risks.is_empty() {
+            println!();
+            println!("Risks");
+            for risk in &report.risks {
+                println!("  {risk}");
+            }
+        }
+
+        if !report.notes.is_empty() {
+            println!();
+            println!("Notes");
+            for note in &report.notes {
+                println!("  {note}");
+            }
+        }
+
+        Ok(())
+    }
+}
+
+fn build_report(snapshot: &project::ProjectSnapshot) -> PlanReport {
+    let project_type = detect_project_type(snapshot);
+    let mut recommended_commands = BTreeMap::new();
+    let mut missing = Vec::new();
+    let mut risks = Vec::new();
+    let mut notes = Vec::new();
+
+    if let Some(script) = first_script(snapshot, &["start", "dev"]) {
+        recommended_commands.insert("dev".to_string(), run_script(snapshot, script));
+    } else if snapshot.electron_dependency.is_some() && snapshot.main.is_some() {
+        recommended_commands.insert("dev".to_string(), package_exec(snapshot, "electron ."));
+        missing.push(
+            "Add a start or dev script so humans and agents have a stable entrypoint.".to_string(),
+        );
+    } else {
+        missing.push("No start or dev script was found.".to_string());
+    }
+
+    if let Some(script) = first_script(snapshot, &["package", "pack"]) {
+        recommended_commands.insert("package".to_string(), run_script(snapshot, script));
+    } else if matches!(project_type, ProjectType::ElectronForge) {
+        missing.push(
+            "No package script was found even though Electron Forge is declared.".to_string(),
+        );
+    }
+
+    if let Some(script) = first_script(snapshot, &["make", "dist"]) {
+        recommended_commands.insert("make".to_string(), run_script(snapshot, script));
+    }
+
+    recommended_commands.insert(
+        "diagnostics".to_string(),
+        "electron-cli doctor --json".to_string(),
+    );
+    recommended_commands.insert(
+        "inspect".to_string(),
+        "electron-cli inspect --json".to_string(),
+    );
+
+    if snapshot.package_json.is_none() {
+        risks.push(
+            "No package.json was found, so Electron project detection is limited.".to_string(),
+        );
+    }
+
+    if snapshot.electron_dependency.is_none() {
+        risks.push("Electron is not declared in package dependencies.".to_string());
+    }
+
+    if snapshot.electron_dependency.is_some() && snapshot.main.is_none() {
+        risks.push("Electron is declared, but package.json has no main process entry.".to_string());
+    }
+
+    if snapshot.has_javascript_dependencies() && snapshot.package_manager.is_none() {
+        risks.push("JavaScript dependencies are declared, but no lockfile was found.".to_string());
+    }
+
+    if matches!(project_type, ProjectType::ElectronForge) {
+        notes.push("Electron Forge was detected; wrapping Forge commands is the safest workflow path today.".to_string());
+    } else if snapshot.electron_dependency.is_some() {
+        notes.push("Electron was detected without Forge; prefer inspection before choosing a packaging path.".to_string());
+    } else {
+        notes.push("This does not currently look like an Electron app.".to_string());
+    }
+
+    PlanReport {
+        project_type,
+        recommended_commands,
+        missing,
+        risks,
+        notes,
+    }
+}
+
+fn detect_project_type(snapshot: &project::ProjectSnapshot) -> ProjectType {
+    if !snapshot.forge_dependencies.is_empty()
+        || snapshot
+            .scripts
+            .values()
+            .any(|script| script.contains("electron-forge"))
+    {
+        ProjectType::ElectronForge
+    } else if snapshot.electron_dependency.is_some() {
+        ProjectType::Electron
+    } else if snapshot.package_json.is_some() {
+        ProjectType::JavaScript
+    } else {
+        ProjectType::Unknown
+    }
+}
+
+fn first_script<'a>(snapshot: &project::ProjectSnapshot, names: &'a [&'a str]) -> Option<&'a str> {
+    names
+        .iter()
+        .copied()
+        .find(|name| snapshot.scripts.contains_key(*name))
+}
+
+fn run_script(snapshot: &project::ProjectSnapshot, script: &str) -> String {
+    match snapshot.package_manager.as_deref() {
+        Some("bun") => format!("bun run {script}"),
+        Some("pnpm") => format!("pnpm run {script}"),
+        Some("yarn") => format!("yarn run {script}"),
+        Some("npm") | None => format!("npm run {script}"),
+        Some(package_manager) => format!("{package_manager} run {script}"),
+    }
+}
+
+fn package_exec(snapshot: &project::ProjectSnapshot, command: &str) -> String {
+    match snapshot.package_manager.as_deref() {
+        Some("bun") => format!("bunx {command}"),
+        Some("pnpm") => format!("pnpm exec {command}"),
+        Some("yarn") => format!("yarn {command}"),
+        Some("npm") | None => format!("npx {command}"),
+        Some(package_manager) => format!("{package_manager} exec {command}"),
+    }
+}
+
+impl ProjectType {
+    fn as_str(&self) -> &'static str {
+        match self {
+            ProjectType::ElectronForge => "electron-forge",
+            ProjectType::Electron => "electron",
+            ProjectType::JavaScript => "javascript",
+            ProjectType::Unknown => "unknown",
+        }
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use std::path::Path;
+
+    use super::*;
+
+    #[test]
+    fn plans_for_electron_forge_fixture() {
+        let fixture = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/electron-forge");
+        let snapshot = project::inspect(&fixture).expect("fixture should inspect");
+
+        let report = build_report(&snapshot);
+
+        assert!(matches!(report.project_type, ProjectType::ElectronForge));
+        assert_eq!(
+            report.recommended_commands.get("dev").map(String::as_str),
+            Some("npm run start")
+        );
+        assert_eq!(
+            report
+                .recommended_commands
+                .get("package")
+                .map(String::as_str),
+            Some("npm run package")
+        );
+        assert!(report.risks.is_empty());
+    }
+}

package/src/main.rs

@@ -0,0 +1,25 @@
+mod cli;
+mod commands;
+mod output;
+mod project;
+
+use anyhow::Result;
+use clap::Parser;
+use cli::{Cli, Commands};
+
+fn main() {
+    if let Err(error) = run() {
+        eprintln!("error: {error:#}");
+        std::process::exit(1);
+    }
+}
+
+fn run() -> Result<()> {
+    let cli = Cli::parse();
+
+    match cli.command {
+        Commands::Doctor(args) => commands::doctor::run(args),
+        Commands::Inspect(args) => commands::inspect::run(args),
+        Commands::Plan(args) => commands::plan::run(args),
+    }
+}

package/src/output.rs

@@ -0,0 +1,7 @@
+use anyhow::Result;
+use serde::Serialize;
+
+pub fn json(value: &impl Serialize) -> Result<()> {
+    println!("{}", serde_json::to_string_pretty(value)?);
+    Ok(())
+}

package/src/project.rs

@@ -0,0 +1,320 @@
+use std::{
+    collections::BTreeMap,
+    fs,
+    path::{Path, PathBuf},
+};
+
+use anyhow::{Context, Result};
+use camino::Utf8PathBuf;
+use serde::Serialize;
+use serde_json::Value;
+
+#[derive(Debug, Serialize)]
+pub struct ProjectSnapshot {
+    pub root: Utf8PathBuf,
+    pub package_json: Option<Utf8PathBuf>,
+    pub name: Option<String>,
+    pub version: Option<String>,
+    pub main: Option<String>,
+    pub package_manager: Option<String>,
+    pub scripts: BTreeMap<String, String>,
+    pub dependencies: BTreeMap<String, String>,
+    pub dev_dependencies: BTreeMap<String, String>,
+    pub optional_dependencies: BTreeMap<String, String>,
+    pub peer_dependencies: BTreeMap<String, String>,
+    pub electron_dependency: Option<String>,
+    pub forge_dependencies: BTreeMap<String, String>,
+    pub signals: Vec<String>,
+}
+
+impl ProjectSnapshot {
+    pub fn package_label(&self) -> Option<String> {
+        match (&self.name, &self.version) {
+            (Some(name), Some(version)) => Some(format!("{name}@{version}")),
+            (Some(name), None) => Some(name.clone()),
+            (None, Some(version)) => Some(format!("version {version}")),
+            (None, None) => None,
+        }
+    }
+
+    pub fn has_javascript_dependencies(&self) -> bool {
+        !self.dependencies.is_empty()
+            || !self.dev_dependencies.is_empty()
+            || !self.optional_dependencies.is_empty()
+            || !self.peer_dependencies.is_empty()
+    }
+}
+
+pub fn inspect(cwd: &Path) -> Result<ProjectSnapshot> {
+    let cwd = cwd
+        .canonicalize()
+        .with_context(|| format!("Could not resolve {}", cwd.display()))?;
+
+    let package_json_path = find_upwards(&cwd, "package.json");
+    let root = package_json_path
+        .as_ref()
+        .and_then(|path| path.parent().map(Path::to_path_buf))
+        .unwrap_or(cwd);
+
+    let package_json = match &package_json_path {
+        Some(path) => {
+            let raw = fs::read_to_string(path)
+                .with_context(|| format!("Could not read {}", path.display()))?;
+            Some(
+                serde_json::from_str::<Value>(&raw)
+                    .with_context(|| format!("Could not parse {}", path.display()))?,
+            )
+        }
+        None => None,
+    };
+
+    let scripts = package_json
+        .as_ref()
+        .map(|package| string_map(package.get("scripts")))
+        .unwrap_or_default();
+
+    let dependencies = package_json
+        .as_ref()
+        .map(|package| string_map(package.get("dependencies")))
+        .unwrap_or_default();
+
+    let dev_dependencies = package_json
+        .as_ref()
+        .map(|package| string_map(package.get("devDependencies")))
+        .unwrap_or_default();
+
+    let optional_dependencies = package_json
+        .as_ref()
+        .map(|package| string_map(package.get("optionalDependencies")))
+        .unwrap_or_default();
+
+    let peer_dependencies = package_json
+        .as_ref()
+        .map(|package| string_map(package.get("peerDependencies")))
+        .unwrap_or_default();
+
+    let all_dependencies = merge_dependencies([
+        &dependencies,
+        &dev_dependencies,
+        &optional_dependencies,
+        &peer_dependencies,
+    ]);
+
+    let electron_dependency = all_dependencies.get("electron").cloned();
+    let forge_dependencies = all_dependencies
+        .iter()
+        .filter(|(name, _)| name.starts_with("@electron-forge/"))
+        .map(|(name, version)| (name.clone(), version.clone()))
+        .collect::<BTreeMap<_, _>>();
+
+    let package_manager = detect_package_manager(&root);
+    let signals = build_signals(
+        &scripts,
+        &all_dependencies,
+        electron_dependency.as_ref(),
+        &forge_dependencies,
+    );
+
+    Ok(ProjectSnapshot {
+        root: utf8_path(root)?,
+        package_json: package_json_path.map(utf8_path).transpose()?,
+        name: package_json
+            .as_ref()
+            .and_then(|package| package.get("name"))
+            .and_then(Value::as_str)
+            .map(ToOwned::to_owned),
+        version: package_json
+            .as_ref()
+            .and_then(|package| package.get("version"))
+            .and_then(Value::as_str)
+            .map(ToOwned::to_owned),
+        main: package_json
+            .as_ref()
+            .and_then(|package| package.get("main"))
+            .and_then(Value::as_str)
+            .map(ToOwned::to_owned),
+        package_manager,
+        scripts,
+        dependencies,
+        dev_dependencies,
+        optional_dependencies,
+        peer_dependencies,
+        electron_dependency,
+        forge_dependencies,
+        signals,
+    })
+}
+
+fn string_map(value: Option<&Value>) -> BTreeMap<String, String> {
+    value
+        .and_then(Value::as_object)
+        .map(|object| {
+            object
+                .iter()
+                .filter_map(|(key, value)| {
+                    value.as_str().map(|value| (key.clone(), value.to_string()))
+                })
+                .collect()
+        })
+        .unwrap_or_default()
+}
+
+fn merge_dependencies<'a>(
+    groups: impl IntoIterator<Item = &'a BTreeMap<String, String>>,
+) -> BTreeMap<String, String> {
+    let mut merged = BTreeMap::new();
+
+    for group in groups {
+        for (name, version) in group {
+            merged.insert(name.clone(), version.clone());
+        }
+    }
+
+    merged
+}
+
+fn detect_package_manager(root: &Path) -> Option<String> {
+    [
+        ("package-lock.json", "npm"),
+        ("npm-shrinkwrap.json", "npm"),
+        ("pnpm-lock.yaml", "pnpm"),
+        ("yarn.lock", "yarn"),
+        ("bun.lock", "bun"),
+        ("bun.lockb", "bun"),
+    ]
+    .iter()
+    .find_map(|(file, manager)| root.join(file).exists().then(|| manager.to_string()))
+}
+
+fn build_signals(
+    scripts: &BTreeMap<String, String>,
+    dependencies: &BTreeMap<String, String>,
+    electron_dependency: Option<&String>,
+    forge_dependencies: &BTreeMap<String, String>,
+) -> Vec<String> {
+    let mut signals = Vec::new();
+
+    if electron_dependency.is_some() {
+        signals.push("electron dependency declared".to_string());
+    }
+
+    if !forge_dependencies.is_empty() {
+        signals.push("electron forge dependency declared".to_string());
+    }
+
+    if dependencies.contains_key("vite") || dependencies.contains_key("@vitejs/plugin-react") {
+        signals.push("vite tooling detected".to_string());
+    }
+
+    if dependencies.contains_key("typescript") {
+        signals.push("typescript tooling detected".to_string());
+    }
+
+    if scripts
+        .values()
+        .any(|script| script.contains("electron") || script.contains("electron-forge"))
+    {
+        signals.push("electron command found in package scripts".to_string());
+    }
+
+    signals
+}
+
+fn find_upwards(start: &Path, file_name: &str) -> Option<PathBuf> {
+    let mut current = Some(start);
+
+    while let Some(path) = current {
+        let candidate = path.join(file_name);
+        if candidate.exists() {
+            return Some(candidate);
+        }
+
+        current = path.parent();
+    }
+
+    None
+}
+
+fn utf8_path(path: PathBuf) -> Result<Utf8PathBuf> {
+    Utf8PathBuf::from_path_buf(path).map_err(|path| {
+        anyhow::anyhow!(
+            "Path contains invalid UTF-8 and cannot be represented in JSON: {}",
+            path.display()
+        )
+    })
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn maps_string_values_only() {
+        let value = serde_json::json!({
+            "electron": "^30.0.0",
+            "bad": false
+        });
+
+        let map = string_map(Some(&value));
+
+        assert_eq!(map.get("electron"), Some(&"^30.0.0".to_string()));
+        assert!(!map.contains_key("bad"));
+    }
+
+    #[test]
+    fn builds_electron_signals() {
+        let mut scripts = BTreeMap::new();
+        scripts.insert("start".to_string(), "electron-forge start".to_string());
+
+        let mut dependencies = BTreeMap::new();
+        dependencies.insert("electron".to_string(), "^30.0.0".to_string());
+        dependencies.insert("@electron-forge/cli".to_string(), "^7.0.0".to_string());
+        dependencies.insert("typescript".to_string(), "^5.0.0".to_string());
+
+        let forge = dependencies
+            .iter()
+            .filter(|(name, _)| name.starts_with("@electron-forge/"))
+            .map(|(name, version)| (name.clone(), version.clone()))
+            .collect::<BTreeMap<_, _>>();
+
+        let signals = build_signals(
+            &scripts,
+            &dependencies,
+            dependencies.get("electron"),
+            &forge,
+        );
+
+        assert!(signals.contains(&"electron dependency declared".to_string()));
+        assert!(signals.contains(&"electron forge dependency declared".to_string()));
+        assert!(signals.contains(&"typescript tooling detected".to_string()));
+        assert!(signals.contains(&"electron command found in package scripts".to_string()));
+    }
+
+    #[test]
+    fn inspects_electron_forge_fixture_from_nested_directory() {
+        let fixture = Path::new(env!("CARGO_MANIFEST_DIR")).join("tests/fixtures/electron-forge");
+        let nested = fixture.join("src");
+
+        let snapshot = inspect(&nested).expect("fixture should inspect");
+
+        assert_eq!(snapshot.name.as_deref(), Some("fixture-electron-forge-app"));
+        assert_eq!(snapshot.version.as_deref(), Some("0.1.0"));
+        assert_eq!(snapshot.main.as_deref(), Some("src/main.ts"));
+        assert_eq!(snapshot.package_manager.as_deref(), Some("npm"));
+        assert_eq!(snapshot.electron_dependency.as_deref(), Some("^31.0.0"));
+        assert_eq!(
+            snapshot
+                .forge_dependencies
+                .get("@electron-forge/cli")
+                .map(String::as_str),
+            Some("^7.0.0")
+        );
+        assert!(snapshot.has_javascript_dependencies());
+        assert!(snapshot
+            .signals
+            .contains(&"electron forge dependency declared".to_string()));
+        assert!(snapshot
+            .signals
+            .contains(&"electron command found in package scripts".to_string()));
+    }
+}

package/tests/fixtures/electron-forge/package-lock.json

@@ -0,0 +1,23 @@
+{
+  "name": "fixture-electron-forge-app",
+  "version": "0.1.0",
+  "lockfileVersion": 3,
+  "requires": true,
+  "packages": {
+    "": {
+      "name": "fixture-electron-forge-app",
+      "version": "0.1.0",
+      "dependencies": {
+        "electron-squirrel-startup": "^1.0.1"
+      },
+      "devDependencies": {
+        "@electron-forge/cli": "^7.0.0",
+        "@electron-forge/maker-squirrel": "^7.0.0",
+        "@electron-forge/plugin-vite": "^7.0.0",
+        "electron": "^31.0.0",
+        "typescript": "^5.5.0",
+        "vite": "^5.0.0"
+      }
+    }
+  }
+}

package/tests/fixtures/electron-forge/package.json

@@ -0,0 +1,21 @@
+{
+  "name": "fixture-electron-forge-app",
+  "version": "0.1.0",
+  "main": "src/main.ts",
+  "scripts": {
+    "start": "electron-forge start",
+    "package": "electron-forge package",
+    "make": "electron-forge make"
+  },
+  "dependencies": {
+    "electron-squirrel-startup": "^1.0.1"
+  },
+  "devDependencies": {
+    "@electron-forge/cli": "^7.0.0",
+    "@electron-forge/maker-squirrel": "^7.0.0",
+    "@electron-forge/plugin-vite": "^7.0.0",
+    "electron": "^31.0.0",
+    "typescript": "^5.5.0",
+    "vite": "^5.0.0"
+  }
+}

package/tests/fixtures/electron-forge/src/main.ts

@@ -0,0 +1,8 @@
+import { app, BrowserWindow } from "electron";
+
+function createWindow() {
+  const window = new BrowserWindow({ width: 800, height: 600 });
+  window.loadURL("about:blank");
+}
+
+app.whenReady().then(createWindow);

package/.babelrc

@@ -1,14 +0,0 @@
-{
-  "presets": ["stage-2","es2015"],
-  "plugins": [
-    "transform-runtime",
-    "syntax-async-functions",
-    "transform-async-to-generator",
-    "transform-object-rest-spread"
-  ],
-  "env": {
-    "test": {
-      "plugins": [ "istanbul" ]
-    }
-  }
-}

package/.eslintrc

@@ -1,7 +0,0 @@
-{
-  "extends": ["airbnb-base","standard"],
-  "rules": {
-    "complexity": [1, { "max": 5 }],
-    "semi": "error"
-  }
-}