amql_engine/

init.rs

//! Stack detection and schema generation for `aql init`.
//!
//! Scans the project directory for stack markers (package.json, go.mod,
//! Cargo.toml) and generates a `.config/aql.schema` with appropriate
//! tag definitions and extractor configurations.

use crate::error::AqlError;
use serde::Serialize;
use std::path::Path;

/// Detected project stack.
#[derive(Debug, Clone, PartialEq, Eq, Serialize)]
#[non_exhaustive]
pub enum Stack {
    /// Node.js with Express
    Express,
    /// Node.js with React
    React,
    /// Node.js (generic, with test framework)
    Node,
    /// Go (HTTP server)
    Go,
    /// Rust
    Rust,
}

/// Result of stack detection.
#[derive(Debug, Clone, Serialize)]
pub struct DetectedStacks {
    /// All detected stacks in the project.
    pub stacks: Vec<Stack>,
    /// Whether a test framework was detected.
    pub has_tests: bool,
}

/// Detect project stacks from marker files in the given directory.
///
/// Reads package.json, go.mod, and Cargo.toml to determine which
/// frameworks are in use.
pub fn detect_stacks(root: &Path) -> DetectedStacks {
    let mut stacks = Vec::new();
    let mut has_tests = false;

    // Check package.json
    if let Ok(content) = std::fs::read_to_string(root.join("package.json")) {
        if let Ok(pkg) = serde_json::from_str::<serde_json::Value>(&content) {
            let all_deps = collect_npm_deps(&pkg);

            if all_deps.contains(&"express") {
                stacks.push(Stack::Express);
            }
            if all_deps.contains(&"react")
                || all_deps.contains(&"react-dom")
                || all_deps.contains(&"next")
            {
                stacks.push(Stack::React);
            }
            if stacks.is_empty() {
                stacks.push(Stack::Node);
            }
            if all_deps.contains(&"jest")
                || all_deps.contains(&"vitest")
                || all_deps.contains(&"mocha")
            {
                has_tests = true;
            }
        }
    }

    // Check go.mod
    if root.join("go.mod").exists() {
        stacks.push(Stack::Go);
    }

    // Check Cargo.toml
    if root.join("Cargo.toml").exists() {
        stacks.push(Stack::Rust);
    }

    DetectedStacks { stacks, has_tests }
}

/// Generate a `.config/aql.schema` XML string for the detected stacks.
pub fn generate_schema(detected: &DetectedStacks) -> String {
    let mut lines = Vec::new();
    lines.push(r#"<schema version="1.0">"#.to_string());

    for stack in &detected.stacks {
        match stack {
            Stack::Express => {
                lines.push(r#"  <define tag="route" description="HTTP route handler">"#.into());
                lines.push(
                    r#"    <attr name="method" type="enum" values="GET,POST,PUT,DELETE,PATCH" required />"#.into(),
                );
                lines.push(r#"    <attr name="path" type="string" required />"#.into());
                lines.push(
                    r#"    <attr name="auth" type="enum" values="required,optional,none" />"#
                        .into(),
                );
                lines.push(r#"  </define>"#.into());
                lines
                    .push(r#"  <define tag="middleware" description="Express middleware">"#.into());
                lines.push(
                    r#"    <attr name="scope" type="enum" values="global,router,route" />"#.into(),
                );
                lines.push(r#"  </define>"#.into());
                lines.push(
                    r#"  <extractor name="express" run="aql extract express" globs="**/*.ts,**/*.js" />"#
                        .into(),
                );
            }
            Stack::React => {
                lines.push(r#"  <define tag="component" description="React component">"#.into());
                lines.push(r#"    <attr name="name" type="string" />"#.into());
                lines.push(r#"  </define>"#.into());
                lines.push(r#"  <define tag="hook" description="React hook">"#.into());
                lines.push(r#"    <attr name="name" type="string" />"#.into());
                lines.push(r#"    <attr name="custom" type="boolean" />"#.into());
                lines.push(r#"  </define>"#.into());
                lines.push(
                    r#"  <extractor name="react" run="aql extract react" globs="**/*.tsx,**/*.jsx" />"#
                        .into(),
                );
            }
            Stack::Node => {
                // Generic Node — no special tags beyond test
            }
            Stack::Go => {
                lines
                    .push(r#"  <define tag="handler" description="HTTP handler function">"#.into());
                lines.push(
                    r#"    <attr name="method" type="enum" values="GET,POST,PUT,DELETE,PATCH" />"#
                        .into(),
                );
                lines.push(r#"    <attr name="path" type="string" />"#.into());
                lines.push(r#"  </define>"#.into());
                lines.push(
                    r#"  <extractor name="go_http" run="aql extract go_http" globs="**/*.go" />"#
                        .into(),
                );
            }
            Stack::Rust => {
                // Rust uses code resolvers, no special tags needed by default
            }
        }
    }

    if detected.has_tests {
        lines.push(r#"  <define tag="describe" description="Test suite">"#.into());
        lines.push(r#"    <attr name="name" type="string" />"#.into());
        lines.push(r#"  </define>"#.into());
        lines.push(r#"  <define tag="test" description="Test case">"#.into());
        lines.push(r#"    <attr name="name" type="string" />"#.into());
        lines.push(r#"    <attr name="skip" type="boolean" />"#.into());
        lines.push(r#"  </define>"#.into());
        lines.push(
            r#"  <extractor name="test" run="aql extract test" globs="**/*.test.ts,**/*.spec.ts,**/*.test.js,**/*.spec.js" />"#
                .into(),
        );
    }

    lines.push("</schema>".to_string());
    lines.join("\n")
}

/// Run `aql init`: detect stacks and write `.config/aql.schema`.
///
/// Returns `Err` if the schema file already exists or the directory
/// cannot be created.
#[cfg(feature = "fs")]
pub fn init_project(root: &Path) -> Result<String, AqlError> {
    let config_dir = root.join(".config");
    let schema_path = config_dir.join("aql.schema");

    if schema_path.exists() {
        return Err(AqlError::new(format!(
            ".config/aql.schema already exists at {}",
            schema_path.display()
        )));
    }

    let detected = detect_stacks(root);
    let schema = generate_schema(&detected);

    std::fs::create_dir_all(&config_dir).map_err(|e| {
        format!(
            "Failed to create .config directory at {}: {e}",
            config_dir.display()
        )
    })?;
    std::fs::write(&schema_path, &schema)
        .map_err(|e| format!("Failed to write schema at {}: {e}", schema_path.display()))?;

    Ok(schema)
}

fn collect_npm_deps(pkg: &serde_json::Value) -> Vec<&str> {
    let mut deps = Vec::new();
    for key in &["dependencies", "devDependencies", "peerDependencies"] {
        if let Some(obj) = pkg.get(key).and_then(|v| v.as_object()) {
            for name in obj.keys() {
                deps.push(name.as_str());
            }
        }
    }
    deps
}

#[cfg(test)]
mod tests {
    use super::*;

    #[test]
    fn detect_stacks_empty_dir() {
        // Arrange and Act
        let detected = detect_stacks(Path::new("/nonexistent"));

        // Assert
        assert!(detected.stacks.is_empty(), "no stacks in nonexistent dir");
        assert!(!detected.has_tests, "no tests in nonexistent dir");
    }

    #[test]
    fn generate_schema_express_with_tests() {
        // Arrange
        let detected = DetectedStacks {
            stacks: vec![Stack::Express],
            has_tests: true,
        };

        // Act
        let schema = generate_schema(&detected);

        // Assert
        assert!(
            schema.contains(r#"<define tag="route""#),
            "should define route tag"
        );
        assert!(
            schema.contains(r#"<extractor name="express""#),
            "should configure express extractor"
        );
        assert!(
            schema.contains(r#"<define tag="test""#),
            "should define test tag when has_tests"
        );
        assert!(
            schema.contains(r#"<extractor name="test""#),
            "should configure test extractor when has_tests"
        );
    }

    #[test]
    fn generate_schema_react() {
        // Arrange
        let detected = DetectedStacks {
            stacks: vec![Stack::React],
            has_tests: false,
        };

        // Act
        let schema = generate_schema(&detected);

        // Assert
        assert!(
            schema.contains(r#"<define tag="component""#),
            "should define component tag"
        );
        assert!(
            schema.contains(r#"<define tag="hook""#),
            "should define hook tag"
        );
        assert!(
            schema.contains(r#"<extractor name="react""#),
            "should configure react extractor"
        );
    }

    #[test]
    fn generate_schema_go() {
        // Arrange
        let detected = DetectedStacks {
            stacks: vec![Stack::Go],
            has_tests: false,
        };

        // Act
        let schema = generate_schema(&detected);

        // Assert
        assert!(
            schema.contains(r#"<define tag="handler""#),
            "should define handler tag"
        );
        assert!(
            schema.contains(r#"<extractor name="go_http""#),
            "should configure go_http extractor"
        );
    }
}