@engramresearch/srun 0.1.0 → 0.1.3

package/src/cli.rs

@@ -1,135 +0,0 @@
-use crate::detect::detect_project;
-use crate::exec::run_command;
-use crate::model::{Intent, ProjectInfo, ResolvedCommand, SrunError};
-use crate::resolve::resolve_intent;
-use clap::{Args, Parser, Subcommand};
-use std::path::PathBuf;
-
-#[derive(Debug, Parser)]
-#[command(name = "srun", about = "Universal Smart Project Runner")]
-pub struct Cli {
-    #[arg(long, global = true, default_value = ".")]
-    pub root: PathBuf,
-
-    #[command(subcommand)]
-    pub command: Command,
-}
-
-#[derive(Debug, Subcommand)]
-pub enum Command {
-    Dev(RunArgs),
-    Build(RunArgs),
-    Installer(RunArgs),
-    Test(RunArgs),
-    Lint(RunArgs),
-    Format(RunArgs),
-    Info,
-}
-
-#[derive(Debug, Args, Clone, Copy)]
-pub struct RunArgs {
-    #[arg(long)]
-    pub dry_run: bool,
-
-    #[arg(long)]
-    pub verbose: bool,
-}
-
-pub fn run(cli: Cli) -> Result<i32, SrunError> {
-    let project = detect_project(&cli.root)?;
-
-    match cli.command {
-        Command::Info => {
-            print_info(&project);
-            Ok(0)
-        }
-        Command::Dev(args) => run_intent(&project, Intent::Dev, args),
-        Command::Build(args) => run_intent(&project, Intent::Build, args),
-        Command::Installer(args) => run_intent(&project, Intent::Installer, args),
-        Command::Test(args) => run_intent(&project, Intent::Test, args),
-        Command::Lint(args) => run_intent(&project, Intent::Lint, args),
-        Command::Format(args) => run_intent(&project, Intent::Format, args),
-    }
-}
-
-fn run_intent(project: &ProjectInfo, intent: Intent, args: RunArgs) -> Result<i32, SrunError> {
-    if args.verbose {
-        print_detect(project);
-    }
-
-    let resolved = resolve_intent(project, intent)?;
-
-    if args.verbose {
-        println!("[resolve]");
-        println!("selected: {}", resolved.command.display());
-        println!("reason: {}", resolved.reason);
-        println!();
-    }
-
-    if args.dry_run {
-        println!("{}", resolved.command.display());
-        return Ok(0);
-    }
-
-    if args.verbose {
-        println!("[exec]");
-        println!("{}", resolved.command.display());
-        println!();
-    }
-
-    let status = run_command(&resolved.command, &project.root)?;
-    Ok(status.code().unwrap_or(1))
-}
-
-pub fn print_info(project: &ProjectInfo) {
-    println!("Project Type: {}", project.project_type());
-    println!(
-        "Package Manager: {}",
-        project
-            .package_manager
-            .map(|package_manager| package_manager.label())
-            .unwrap_or("none")
-    );
-
-    if !project.warnings.is_empty() {
-        println!();
-        println!("Warnings:");
-        for warning in &project.warnings {
-            println!("  - {}", warning);
-        }
-    }
-
-    println!();
-    println!("Resolved Commands:");
-    for intent in Intent::EXECUTABLE {
-        print_resolved_line(project, intent);
-    }
-}
-
-fn print_resolved_line(project: &ProjectInfo, intent: Intent) {
-    match resolve_intent(project, intent) {
-        Ok(resolved) => println!("{}:\n  {}", intent.label(), resolved.command.display()),
-        Err(error) => println!("{}:\n  unavailable ({})", intent.label(), error),
-    }
-}
-
-fn print_detect(project: &ProjectInfo) {
-    println!("[detect]");
-    for trace in &project.traces {
-        println!("{}", trace);
-    }
-    for warning in &project.warnings {
-        println!("warning: {}", warning);
-    }
-    println!("project type: {}", project.project_type());
-    println!();
-}
-
-#[allow(dead_code)]
-fn _format_resolved(resolved: &ResolvedCommand) -> String {
-    format!(
-        "{} -> {}",
-        resolved.intent.label(),
-        resolved.command.display()
-    )
-}

package/src/detect.rs

@@ -1,232 +0,0 @@
-use crate::manifest::read_package_json;
-use crate::model::{Framework, PackageManager, ProjectInfo, SrunError};
-use std::collections::BTreeSet;
-use std::path::Path;
-
-pub fn detect_project(root: &Path) -> Result<ProjectInfo, SrunError> {
-    let package_json = read_package_json(root)?;
-    let has_package_json = package_json.is_some();
-    let has_cargo_toml = root.join("Cargo.toml").exists();
-    let (package_manager, mut warnings, mut traces) =
-        detect_package_manager(root, has_package_json);
-    let mut frameworks = BTreeSet::new();
-
-    if let Some(package_json) = &package_json {
-        let deps = &package_json.dependencies;
-        let scripts = package_json
-            .scripts
-            .keys()
-            .map(String::as_str)
-            .collect::<BTreeSet<_>>();
-
-        if deps.contains("electron")
-            || deps.contains("electron-builder")
-            || deps.contains("electron-vite")
-            || root.join("electron").is_dir()
-            || has_file_prefix(root, "electron.vite.config.")
-        {
-            frameworks.insert(Framework::Electron);
-            traces.push("found electron markers".to_string());
-        }
-
-        if root.join("src-tauri").is_dir()
-            || root.join("tauri.conf.json").exists()
-            || deps.iter().any(|dep| dep.contains("tauri"))
-            || scripts.iter().any(|script| script.contains("tauri"))
-        {
-            frameworks.insert(Framework::Tauri);
-            traces.push("found tauri markers".to_string());
-        }
-
-        if deps.contains("next") || has_file_prefix(root, "next.config.") {
-            frameworks.insert(Framework::Next);
-            traces.push("found next markers".to_string());
-        }
-
-        if deps.contains("vite") || has_file_prefix(root, "vite.config.") {
-            frameworks.insert(Framework::Vite);
-            traces.push("found vite markers".to_string());
-        }
-    } else {
-        if root.join("src-tauri").is_dir() || root.join("tauri.conf.json").exists() {
-            frameworks.insert(Framework::Tauri);
-            traces.push("found tauri markers".to_string());
-        }
-    }
-
-    if root.join("turbo.json").exists() {
-        frameworks.insert(Framework::Turbo);
-        traces.push("found turbo.json".to_string());
-    }
-
-    if root.join("nx.json").exists() {
-        frameworks.insert(Framework::Nx);
-        traces.push("found nx.json".to_string());
-    }
-
-    let is_monorepo = root.join("apps").is_dir()
-        || root.join("packages").is_dir()
-        || frameworks.contains(&Framework::Turbo)
-        || frameworks.contains(&Framework::Nx);
-
-    if is_monorepo {
-        traces.push("found monorepo markers".to_string());
-    }
-
-    warnings.retain(|warning| !warning.is_empty());
-
-    Ok(ProjectInfo {
-        root: root.to_path_buf(),
-        package_manager,
-        package_json,
-        frameworks,
-        has_cargo_toml,
-        has_package_json,
-        is_monorepo,
-        warnings,
-        traces,
-    })
-}
-
-fn detect_package_manager(
-    root: &Path,
-    has_package_json: bool,
-) -> (Option<PackageManager>, Vec<String>, Vec<String>) {
-    let mut found = Vec::new();
-    let mut traces = Vec::new();
-
-    if root.join("pnpm-lock.yaml").exists() {
-        found.push(PackageManager::Pnpm);
-        traces.push("found pnpm-lock.yaml".to_string());
-    }
-    if root.join("bun.lockb").exists() || root.join("bun.lock").exists() {
-        found.push(PackageManager::Bun);
-        traces.push("found bun lockfile".to_string());
-    }
-    if root.join("yarn.lock").exists() {
-        found.push(PackageManager::Yarn);
-        traces.push("found yarn.lock".to_string());
-    }
-    if root.join("package-lock.json").exists() {
-        found.push(PackageManager::Npm);
-        traces.push("found package-lock.json".to_string());
-    }
-
-    let selected = [
-        PackageManager::Pnpm,
-        PackageManager::Bun,
-        PackageManager::Yarn,
-        PackageManager::Npm,
-    ]
-    .into_iter()
-    .find(|package_manager| found.contains(package_manager))
-    .or_else(|| has_package_json.then_some(PackageManager::Npm));
-
-    let mut warnings = Vec::new();
-    if found.len() > 1 {
-        if let Some(selected) = selected {
-            warnings.push(format!(
-                "Multiple package managers detected. Using {}.",
-                selected.label()
-            ));
-        }
-    } else if found.is_empty() && has_package_json {
-        warnings.push("No lockfile found. Using npm.".to_string());
-    }
-
-    (selected, warnings, traces)
-}
-
-fn has_file_prefix(root: &Path, prefix: &str) -> bool {
-    let Ok(entries) = std::fs::read_dir(root) else {
-        return false;
-    };
-
-    entries.filter_map(Result::ok).any(|entry| {
-        entry
-            .file_name()
-            .to_str()
-            .map(|file_name| file_name.starts_with(prefix))
-            .unwrap_or(false)
-    })
-}
-
-#[cfg(test)]
-mod tests {
-    use super::detect_project;
-    use crate::model::{Framework, PackageManager};
-    use std::fs;
-    use tempfile::tempdir;
-
-    #[test]
-    fn selects_pnpm_over_other_lockfiles() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(dir.path().join("package.json"), "{}").expect("package");
-        fs::write(dir.path().join("pnpm-lock.yaml"), "").expect("pnpm");
-        fs::write(dir.path().join("package-lock.json"), "").expect("npm");
-
-        let project = detect_project(dir.path()).expect("project");
-
-        assert_eq!(project.package_manager, Some(PackageManager::Pnpm));
-        assert!(project
-            .warnings
-            .iter()
-            .any(|warning| warning.contains("Multiple")));
-    }
-
-    #[test]
-    fn falls_back_to_npm_for_package_json_without_lock() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(dir.path().join("package.json"), "{}").expect("package");
-
-        let project = detect_project(dir.path()).expect("project");
-
-        assert_eq!(project.package_manager, Some(PackageManager::Npm));
-        assert!(project
-            .warnings
-            .iter()
-            .any(|warning| warning.contains("No lockfile")));
-    }
-
-    #[test]
-    fn detects_electron_and_vite() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(
-            dir.path().join("package.json"),
-            r#"{"dependencies":{"electron":"latest","vite":"latest"}}"#,
-        )
-        .expect("package");
-
-        let project = detect_project(dir.path()).expect("project");
-
-        assert!(project.frameworks.contains(&Framework::Electron));
-        assert!(project.frameworks.contains(&Framework::Vite));
-    }
-
-    #[test]
-    fn detects_tauri_next_and_monorepo() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(
-            dir.path().join("package.json"),
-            r#"{"dependencies":{"next":"latest"},"scripts":{"tauri:dev":"tauri dev"}}"#,
-        )
-        .expect("package");
-        fs::create_dir(dir.path().join("apps")).expect("apps");
-
-        let project = detect_project(dir.path()).expect("project");
-
-        assert!(project.frameworks.contains(&Framework::Tauri));
-        assert!(project.frameworks.contains(&Framework::Next));
-        assert!(project.is_monorepo);
-    }
-
-    #[test]
-    fn detects_cargo_only() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(dir.path().join("Cargo.toml"), "[package]\nname='x'").expect("cargo");
-
-        let project = detect_project(dir.path()).expect("project");
-
-        assert!(project.is_cargo_only());
-    }
-}

package/src/exec.rs

@@ -1,80 +0,0 @@
-use crate::model::{CommandSpec, SrunError};
-use std::io;
-use std::path::Path;
-use std::process::{Command, ExitStatus, Stdio};
-
-pub fn run_command(command: &CommandSpec, cwd: &Path) -> Result<ExitStatus, SrunError> {
-    spawn_command(command, cwd).map_err(|source| SrunError::ProcessSpawn {
-        command: command.display(),
-        source,
-    })
-}
-
-fn spawn_command(command: &CommandSpec, cwd: &Path) -> io::Result<ExitStatus> {
-    match spawn_program(&command.program, &command.args, cwd) {
-        Ok(status) => Ok(status),
-        Err(error) if should_try_windows_cmd_shim(&command.program, &error) => {
-            spawn_program(&format!("{}.cmd", command.program), &command.args, cwd)
-        }
-        Err(error) => Err(error),
-    }
-}
-
-fn spawn_program(program: &str, args: &[String], cwd: &Path) -> io::Result<ExitStatus> {
-    Command::new(program)
-        .args(args)
-        .current_dir(cwd)
-        .stdin(Stdio::inherit())
-        .stdout(Stdio::inherit())
-        .stderr(Stdio::inherit())
-        .status()
-}
-
-fn should_try_windows_cmd_shim(program: &str, error: &io::Error) -> bool {
-    cfg!(windows)
-        && error.kind() == io::ErrorKind::NotFound
-        && matches!(program, "npm" | "pnpm" | "yarn" | "bun" | "npx")
-}
-
-#[cfg(test)]
-mod tests {
-    use super::should_try_windows_cmd_shim;
-    use crate::model::{CommandSpec, PackageManager};
-    use std::io;
-
-    #[test]
-    fn builds_package_manager_commands_without_shell() {
-        assert_eq!(
-            PackageManager::Pnpm.script_command("dev").display(),
-            "pnpm run dev"
-        );
-        assert_eq!(
-            PackageManager::Npm.script_command("dev").display(),
-            "npm run dev"
-        );
-        assert_eq!(
-            PackageManager::Bun.script_command("dev").display(),
-            "bun run dev"
-        );
-        assert_eq!(
-            PackageManager::Yarn.script_command("dev").display(),
-            "yarn dev"
-        );
-    }
-
-    #[test]
-    fn displays_program_without_args() {
-        assert_eq!(
-            CommandSpec::new("srun", std::iter::empty::<&str>()).display(),
-            "srun"
-        );
-    }
-
-    #[test]
-    fn windows_shim_fallback_only_applies_to_package_managers() {
-        let error = io::Error::new(io::ErrorKind::NotFound, "missing");
-
-        assert_eq!(should_try_windows_cmd_shim("npm", &error), cfg!(windows));
-        assert!(!should_try_windows_cmd_shim("cargo", &error));
-    }
-}

package/src/lib.rs

@@ -1,10 +0,0 @@
-pub mod cli;
-pub mod detect;
-pub mod exec;
-pub mod manifest;
-pub mod model;
-pub mod resolve;
-
-pub use detect::detect_project;
-pub use model::{Intent, ProjectInfo, ResolvedCommand, SrunError};
-pub use resolve::resolve_intent;

package/src/main.rs

@@ -1,13 +0,0 @@
-use clap::Parser;
-use srun::cli::{run, Cli};
-
-fn main() {
-    let cli = Cli::parse();
-    match run(cli) {
-        Ok(code) => std::process::exit(code),
-        Err(error) => {
-            eprintln!("error: {}", error);
-            std::process::exit(1);
-        }
-    }
-}

package/src/manifest.rs

@@ -1,81 +0,0 @@
-use crate::model::{PackageJson, SrunError};
-use serde::Deserialize;
-use std::collections::{BTreeMap, BTreeSet};
-use std::fs;
-use std::path::Path;
-
-#[derive(Debug, Deserialize, Default)]
-struct RawPackageJson {
-    #[serde(default)]
-    scripts: BTreeMap<String, String>,
-    #[serde(default)]
-    dependencies: BTreeMap<String, serde_json::Value>,
-    #[serde(default, rename = "devDependencies")]
-    dev_dependencies: BTreeMap<String, serde_json::Value>,
-}
-
-pub fn read_package_json(root: &Path) -> Result<Option<PackageJson>, SrunError> {
-    let path = root.join("package.json");
-    if !path.exists() {
-        return Ok(None);
-    }
-
-    let content = fs::read_to_string(&path).map_err(|source| SrunError::Io {
-        path: path.clone(),
-        source,
-    })?;
-    let raw: RawPackageJson = serde_json::from_str(&content).map_err(|source| SrunError::Json {
-        path: path.clone(),
-        source,
-    })?;
-
-    let dependencies = raw
-        .dependencies
-        .into_keys()
-        .chain(raw.dev_dependencies.into_keys())
-        .collect::<BTreeSet<_>>();
-
-    Ok(Some(PackageJson {
-        scripts: raw.scripts,
-        dependencies,
-    }))
-}
-
-#[cfg(test)]
-mod tests {
-    use super::read_package_json;
-    use std::fs;
-    use tempfile::tempdir;
-
-    #[test]
-    fn reads_scripts_and_dependencies() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(
-            dir.path().join("package.json"),
-            r#"{
-              "scripts": { "dev": "vite" },
-              "dependencies": { "vite": "latest" },
-              "devDependencies": { "electron": "latest" }
-            }"#,
-        )
-        .expect("write package");
-
-        let package = read_package_json(dir.path())
-            .expect("read package")
-            .expect("package");
-
-        assert_eq!(package.scripts.get("dev"), Some(&"vite".to_string()));
-        assert!(package.dependencies.contains("vite"));
-        assert!(package.dependencies.contains("electron"));
-    }
-
-    #[test]
-    fn reports_invalid_json() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(dir.path().join("package.json"), "{").expect("write package");
-
-        let error = read_package_json(dir.path()).expect_err("invalid json should fail");
-
-        assert!(error.to_string().contains("failed to parse"));
-    }
-}