@engramresearch/srun 0.1.0 → 0.1.3

package/src/model.rs

@@ -1,262 +0,0 @@
-use std::collections::{BTreeMap, BTreeSet};
-use std::fmt;
-use std::path::PathBuf;
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Intent {
-    Dev,
-    Build,
-    Installer,
-    Test,
-    Lint,
-    Format,
-}
-
-impl Intent {
-    pub const EXECUTABLE: [Intent; 6] = [
-        Intent::Dev,
-        Intent::Build,
-        Intent::Installer,
-        Intent::Test,
-        Intent::Lint,
-        Intent::Format,
-    ];
-
-    pub fn label(self) -> &'static str {
-        match self {
-            Intent::Dev => "dev",
-            Intent::Build => "build",
-            Intent::Installer => "installer",
-            Intent::Test => "test",
-            Intent::Lint => "lint",
-            Intent::Format => "format",
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum PackageManager {
-    Pnpm,
-    Bun,
-    Yarn,
-    Npm,
-}
-
-impl PackageManager {
-    pub fn label(self) -> &'static str {
-        match self {
-            PackageManager::Pnpm => "pnpm",
-            PackageManager::Bun => "bun",
-            PackageManager::Yarn => "yarn",
-            PackageManager::Npm => "npm",
-        }
-    }
-
-    pub fn script_command(self, script: &str) -> CommandSpec {
-        match self {
-            PackageManager::Pnpm => CommandSpec::new("pnpm", ["run", script]),
-            PackageManager::Bun => CommandSpec::new("bun", ["run", script]),
-            PackageManager::Yarn => CommandSpec::new("yarn", [script]),
-            PackageManager::Npm => CommandSpec::new("npm", ["run", script]),
-        }
-    }
-}
-
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord, Hash)]
-pub enum Framework {
-    Electron,
-    Tauri,
-    Next,
-    Vite,
-    Turbo,
-    Nx,
-}
-
-impl Framework {
-    pub fn label(self) -> &'static str {
-        match self {
-            Framework::Electron => "Electron",
-            Framework::Tauri => "Tauri",
-            Framework::Next => "Next.js",
-            Framework::Vite => "Vite",
-            Framework::Turbo => "TurboRepo",
-            Framework::Nx => "NX",
-        }
-    }
-}
-
-#[derive(Debug, Clone, Default)]
-pub struct PackageJson {
-    pub scripts: BTreeMap<String, String>,
-    pub dependencies: BTreeSet<String>,
-}
-
-#[derive(Debug, Clone)]
-pub struct ProjectInfo {
-    pub root: PathBuf,
-    pub package_manager: Option<PackageManager>,
-    pub package_json: Option<PackageJson>,
-    pub frameworks: BTreeSet<Framework>,
-    pub has_cargo_toml: bool,
-    pub has_package_json: bool,
-    pub is_monorepo: bool,
-    pub warnings: Vec<String>,
-    pub traces: Vec<String>,
-}
-
-impl ProjectInfo {
-    pub fn project_type(&self) -> String {
-        if self.is_cargo_only() {
-            return "Cargo".to_string();
-        }
-
-        let mut labels: Vec<&str> = self
-            .frameworks
-            .iter()
-            .map(|framework| framework.label())
-            .collect();
-        if self.is_monorepo {
-            labels.push("Monorepo");
-        }
-
-        if labels.is_empty() {
-            if self.has_package_json {
-                "Node.js".to_string()
-            } else {
-                "Unknown".to_string()
-            }
-        } else {
-            labels.join(" + ")
-        }
-    }
-
-    pub fn scripts(&self) -> BTreeMap<String, String> {
-        self.package_json
-            .as_ref()
-            .map(|package_json| package_json.scripts.clone())
-            .unwrap_or_default()
-    }
-
-    pub fn has_framework(&self, framework: Framework) -> bool {
-        self.frameworks.contains(&framework)
-    }
-
-    pub fn is_cargo_only(&self) -> bool {
-        self.has_cargo_toml && !self.has_package_json
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct CommandSpec {
-    pub program: String,
-    pub args: Vec<String>,
-}
-
-impl CommandSpec {
-    pub fn new<I, S>(program: impl Into<String>, args: I) -> Self
-    where
-        I: IntoIterator<Item = S>,
-        S: Into<String>,
-    {
-        Self {
-            program: program.into(),
-            args: args.into_iter().map(Into::into).collect(),
-        }
-    }
-
-    pub fn display(&self) -> String {
-        if self.args.is_empty() {
-            self.program.clone()
-        } else {
-            format!("{} {}", self.program, self.args.join(" "))
-        }
-    }
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ResolvedCommand {
-    pub intent: Intent,
-    pub command: CommandSpec,
-    pub reason: String,
-    pub script: Option<String>,
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ResolveFailure {
-    NoProjectDetected,
-    NoPackageManager,
-    NoMatchingScript { candidates: Vec<String> },
-    UnsupportedIntent,
-}
-
-#[derive(Debug)]
-pub enum SrunError {
-    Io {
-        path: PathBuf,
-        source: std::io::Error,
-    },
-    Json {
-        path: PathBuf,
-        source: serde_json::Error,
-    },
-    Resolve {
-        intent: Intent,
-        failure: ResolveFailure,
-    },
-    ProcessSpawn {
-        command: String,
-        source: std::io::Error,
-    },
-}
-
-impl fmt::Display for SrunError {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            SrunError::Io { path, source } => {
-                write!(formatter, "failed to read {}: {}", path.display(), source)
-            }
-            SrunError::Json { path, source } => {
-                write!(formatter, "failed to parse {}: {}", path.display(), source)
-            }
-            SrunError::Resolve { intent, failure } => write!(
-                formatter,
-                "could not resolve {}: {}",
-                intent.label(),
-                failure
-            ),
-            SrunError::ProcessSpawn { command, source } => {
-                write!(formatter, "failed to execute `{}`: {}", command, source)
-            }
-        }
-    }
-}
-
-impl std::error::Error for SrunError {}
-
-impl fmt::Display for ResolveFailure {
-    fn fmt(&self, formatter: &mut fmt::Formatter<'_>) -> fmt::Result {
-        match self {
-            ResolveFailure::NoProjectDetected => {
-                write!(formatter, "no supported project files found")
-            }
-            ResolveFailure::NoPackageManager => write!(
-                formatter,
-                "package.json exists but no package manager could be selected"
-            ),
-            ResolveFailure::NoMatchingScript { candidates } => {
-                if candidates.is_empty() {
-                    write!(formatter, "no matching script found")
-                } else {
-                    write!(
-                        formatter,
-                        "no matching script found. Possible candidates: {}",
-                        candidates.join(", ")
-                    )
-                }
-            }
-            ResolveFailure::UnsupportedIntent => {
-                write!(formatter, "intent is not supported for this project type")
-            }
-        }
-    }
-}

package/src/resolve.rs

@@ -1,269 +0,0 @@
-use crate::model::{
-    CommandSpec, Framework, Intent, ProjectInfo, ResolveFailure, ResolvedCommand, SrunError,
-};
-
-pub fn resolve_intent(project: &ProjectInfo, intent: Intent) -> Result<ResolvedCommand, SrunError> {
-    if project.is_cargo_only() {
-        return resolve_cargo(intent);
-    }
-
-    if !project.has_package_json && !project.has_cargo_toml {
-        return Err(resolve_error(intent, ResolveFailure::NoProjectDetected));
-    }
-
-    let package_manager = project
-        .package_manager
-        .ok_or_else(|| resolve_error(intent, ResolveFailure::NoPackageManager))?;
-    let scripts = project.scripts();
-    let candidates = candidates_for(project, intent);
-
-    for candidate in candidates {
-        if scripts.contains_key(candidate) {
-            return Ok(ResolvedCommand {
-                intent,
-                command: package_manager.script_command(candidate),
-                reason: reason_for(project, intent, candidate),
-                script: Some(candidate.to_string()),
-            });
-        }
-    }
-
-    Err(resolve_error(
-        intent,
-        ResolveFailure::NoMatchingScript {
-            candidates: fallback_candidates(&scripts),
-        },
-    ))
-}
-
-pub fn candidates_for(project: &ProjectInfo, intent: Intent) -> Vec<&'static str> {
-    match intent {
-        Intent::Dev if project.has_framework(Framework::Electron) => vec![
-            "dev:electron",
-            "electron:dev",
-            "desktop:dev",
-            "dev",
-            "dev:web",
-            "tauri:dev",
-            "app:dev",
-            "start",
-            "serve",
-            "watch",
-        ],
-        Intent::Dev if project.has_framework(Framework::Tauri) => vec![
-            "tauri:dev",
-            "dev:tauri",
-            "desktop:dev",
-            "dev",
-            "dev:web",
-            "dev:electron",
-            "electron:dev",
-            "app:dev",
-            "start",
-            "serve",
-            "watch",
-        ],
-        Intent::Dev => vec![
-            "dev",
-            "dev:web",
-            "dev:electron",
-            "electron:dev",
-            "tauri:dev",
-            "desktop:dev",
-            "app:dev",
-            "start",
-            "serve",
-            "watch",
-        ],
-        Intent::Build if project.has_framework(Framework::Electron) => vec![
-            "build:electron",
-            "electron:build",
-            "desktop:build",
-            "build",
-            "build:web",
-            "tauri:build",
-            "dist",
-            "compile",
-            "bundle",
-        ],
-        Intent::Build if project.has_framework(Framework::Tauri) => vec![
-            "tauri:build",
-            "build:tauri",
-            "desktop:build",
-            "build",
-            "build:web",
-            "build:electron",
-            "electron:build",
-            "dist",
-            "compile",
-            "bundle",
-        ],
-        Intent::Build => vec![
-            "build",
-            "build:web",
-            "build:electron",
-            "electron:build",
-            "tauri:build",
-            "dist",
-            "compile",
-            "bundle",
-        ],
-        Intent::Installer => vec![
-            "installer",
-            "installer:win",
-            "package",
-            "make",
-            "dist",
-            "release",
-            "bundle",
-        ],
-        Intent::Test => vec!["test", "tests", "check", "ci:test"],
-        Intent::Lint => vec!["lint", "lint:check", "eslint", "clippy"],
-        Intent::Format => vec!["format", "fmt", "prettier", "format:check"],
-    }
-}
-
-fn resolve_cargo(intent: Intent) -> Result<ResolvedCommand, SrunError> {
-    let command = match intent {
-        Intent::Dev => CommandSpec::new("cargo", ["run"]),
-        Intent::Build => CommandSpec::new("cargo", ["build"]),
-        Intent::Test => CommandSpec::new("cargo", ["test"]),
-        Intent::Lint => CommandSpec::new("cargo", ["clippy"]),
-        Intent::Format => CommandSpec::new("cargo", ["fmt"]),
-        Intent::Installer => return Err(resolve_error(intent, ResolveFailure::UnsupportedIntent)),
-    };
-
-    Ok(ResolvedCommand {
-        intent,
-        command,
-        reason: "Cargo-only project fallback".to_string(),
-        script: None,
-    })
-}
-
-fn reason_for(project: &ProjectInfo, intent: Intent, script: &str) -> String {
-    if intent == Intent::Dev
-        && project.has_framework(Framework::Electron)
-        && script.contains("electron")
-    {
-        return "Electron project: desktop dev script has priority".to_string();
-    }
-    if intent == Intent::Build
-        && project.has_framework(Framework::Electron)
-        && script.contains("electron")
-    {
-        return "Electron project: desktop build script has priority".to_string();
-    }
-    if project.has_framework(Framework::Tauri) && script.contains("tauri") {
-        return "Tauri project: tauri script has priority".to_string();
-    }
-
-    format!("selected first matching {} script", intent.label())
-}
-
-fn fallback_candidates(scripts: &std::collections::BTreeMap<String, String>) -> Vec<String> {
-    scripts.keys().take(8).cloned().collect()
-}
-
-fn resolve_error(intent: Intent, failure: ResolveFailure) -> SrunError {
-    SrunError::Resolve { intent, failure }
-}
-
-#[cfg(test)]
-mod tests {
-    use super::{candidates_for, resolve_intent};
-    use crate::detect::detect_project;
-    use crate::model::{Framework, Intent};
-    use std::fs;
-    use tempfile::tempdir;
-
-    #[test]
-    fn preserves_base_dev_order_for_simple_projects() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(
-            dir.path().join("package.json"),
-            r#"{"scripts":{"dev":"next dev"}}"#,
-        )
-        .expect("package");
-
-        let project = detect_project(dir.path()).expect("project");
-        let candidates = candidates_for(&project, Intent::Dev);
-
-        assert_eq!(candidates[0], "dev");
-    }
-
-    #[test]
-    fn resolves_next_dev() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(dir.path().join("pnpm-lock.yaml"), "").expect("lock");
-        fs::write(
-            dir.path().join("package.json"),
-            r#"{"scripts":{"dev":"next dev"},"dependencies":{"next":"latest"}}"#,
-        )
-        .expect("package");
-
-        let project = detect_project(dir.path()).expect("project");
-        let resolved = resolve_intent(&project, Intent::Dev).expect("resolved");
-
-        assert_eq!(resolved.command.display(), "pnpm run dev");
-    }
-
-    #[test]
-    fn prioritizes_electron_dev_script() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(dir.path().join("pnpm-lock.yaml"), "").expect("lock");
-        fs::write(
-            dir.path().join("package.json"),
-            r#"{"scripts":{"dev":"vite","dev:electron":"electron-vite dev"},"devDependencies":{"electron":"latest"}}"#,
-        )
-        .expect("package");
-
-        let project = detect_project(dir.path()).expect("project");
-        assert!(project.frameworks.contains(&Framework::Electron));
-        let resolved = resolve_intent(&project, Intent::Dev).expect("resolved");
-
-        assert_eq!(resolved.command.display(), "pnpm run dev:electron");
-    }
-
-    #[test]
-    fn prioritizes_tauri_dev_script() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(dir.path().join("pnpm-lock.yaml"), "").expect("lock");
-        fs::write(
-            dir.path().join("package.json"),
-            r#"{"scripts":{"dev":"vite","tauri:dev":"tauri dev"}}"#,
-        )
-        .expect("package");
-
-        let project = detect_project(dir.path()).expect("project");
-        let resolved = resolve_intent(&project, Intent::Dev).expect("resolved");
-
-        assert_eq!(resolved.command.display(), "pnpm run tauri:dev");
-    }
-
-    #[test]
-    fn resolves_cargo_project() {
-        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");
-        let resolved = resolve_intent(&project, Intent::Dev).expect("resolved");
-
-        assert_eq!(resolved.command.display(), "cargo run");
-    }
-
-    #[test]
-    fn custom_script_returns_candidates_instead_of_guessing() {
-        let dir = tempdir().expect("tempdir");
-        fs::write(
-            dir.path().join("package.json"),
-            r#"{"scripts":{"banana":"vite"}}"#,
-        )
-        .expect("package");
-
-        let project = detect_project(dir.path()).expect("project");
-        let error = resolve_intent(&project, Intent::Dev).expect_err("should not guess");
-
-        assert!(error.to_string().contains("banana"));
-    }
-}