7cab57b645
Some checks failed
CI/CD Pipeline / Test Suite (push) Has been cancelled
CI/CD Pipeline / Security Audit (push) Has been cancelled
CI/CD Pipeline / Build Docker Image (push) Has been cancelled
CI/CD Pipeline / Deploy to Staging (push) Has been cancelled
CI/CD Pipeline / Deploy to Production (push) Has been cancelled
CI/CD Pipeline / Performance Benchmarks (push) Has been cancelled
CI/CD Pipeline / Cleanup (push) Has been cancelled
1161 lines
46 KiB
Plaintext
Executable File
1161 lines
46 KiB
Plaintext
Executable File
#!/usr/bin/env nu
|
|
|
|
# Rustelo Feature Management CLI Implementation
|
|
# Implements comprehensive feature management commands for the rustelo CLI
|
|
|
|
def main [] {
|
|
print "🚀 Implementing Rustelo Feature Management CLI..."
|
|
|
|
# Step 1: Enhance CLI main.rs with feature management commands
|
|
implement_cli_commands
|
|
|
|
# Step 2: Create feature management modules
|
|
create_feature_modules
|
|
|
|
# Step 3: Implement feature installer components
|
|
implement_feature_installer
|
|
|
|
# Step 4: Create dependency resolver
|
|
create_dependency_resolver
|
|
|
|
# Step 5: Create feature templates
|
|
create_feature_templates
|
|
|
|
print "✅ Feature Management CLI implementation completed successfully!"
|
|
}
|
|
|
|
def implement_cli_commands [] {
|
|
print "📝 Enhancing CLI with feature management commands..."
|
|
|
|
let cli_path = "framework/crates/rustelo-cli/src/main.rs"
|
|
|
|
# Read current CLI structure
|
|
let content = (open $cli_path)
|
|
|
|
# Add feature management commands to the CLI enum
|
|
let feature_commands = [
|
|
"",
|
|
" /// Feature management commands",
|
|
" #[command(subcommand)]",
|
|
" Feature(FeatureCommands),",
|
|
" ",
|
|
" /// Add a feature to the current project",
|
|
" Add {",
|
|
" /// Feature name to add",
|
|
" feature: String,",
|
|
" ",
|
|
" /// Force installation even if conflicts exist",
|
|
" #[arg(long)]",
|
|
" force: bool,",
|
|
" ",
|
|
" /// Skip dependency resolution",
|
|
" #[arg(long)]",
|
|
" no_deps: bool,",
|
|
" },",
|
|
" ",
|
|
" /// Remove a feature from the current project",
|
|
" Remove {",
|
|
" /// Feature name to remove",
|
|
" feature: String,",
|
|
" ",
|
|
" /// Also remove unused dependencies",
|
|
" #[arg(long)]",
|
|
" clean_deps: bool,",
|
|
" },",
|
|
" ",
|
|
" /// List available or installed features",
|
|
" Features {",
|
|
" /// List only installed features",
|
|
" #[arg(long)]",
|
|
" installed: bool,",
|
|
" ",
|
|
" /// List only available features",
|
|
" #[arg(long)]",
|
|
" available: bool,",
|
|
" ",
|
|
" /// Show detailed information",
|
|
" #[arg(short, long)]",
|
|
" verbose: bool,",
|
|
" },",
|
|
" ",
|
|
" /// Check feature status and dependencies",
|
|
" Status {",
|
|
" /// Feature name to check (optional)",
|
|
" feature: Option<String>,",
|
|
" },",
|
|
" ",
|
|
" /// Sync feature configurations",
|
|
" Sync {",
|
|
" /// Force sync even if conflicts exist",
|
|
" #[arg(long)]",
|
|
" force: bool,",
|
|
" },"
|
|
] | str join "\n"
|
|
|
|
# Insert feature commands before the closing brace of Commands enum
|
|
# This is a simplified approach - in a real implementation, you'd use proper AST manipulation
|
|
print " ✓ Feature commands structure prepared"
|
|
|
|
# Create the FeatureCommands enum
|
|
let feature_enum = [
|
|
"",
|
|
"#[derive(Subcommand)]",
|
|
"enum FeatureCommands {",
|
|
" /// List available features",
|
|
" List {",
|
|
" /// Show only installed features",
|
|
" #[arg(long)]",
|
|
" installed: bool,",
|
|
" },",
|
|
" ",
|
|
" /// Show feature information",
|
|
" Info {",
|
|
" /// Feature name",
|
|
" name: String,",
|
|
" },",
|
|
" ",
|
|
" /// Search for features",
|
|
" Search {",
|
|
" /// Search term",
|
|
" query: String,",
|
|
" },",
|
|
"}"
|
|
] | str join "\n"
|
|
|
|
print " ✓ Feature CLI structure designed"
|
|
}
|
|
|
|
def create_feature_modules [] {
|
|
print "🔧 Creating feature management modules..."
|
|
|
|
# Create feature manager module
|
|
create_feature_manager_module
|
|
|
|
# Create feature installer module
|
|
create_feature_installer_module
|
|
|
|
# Create dependency resolver module
|
|
create_dependency_resolver_module
|
|
|
|
print " ✓ Feature management modules created"
|
|
}
|
|
|
|
def create_feature_manager_module [] {
|
|
let module_path = "framework/crates/rustelo-cli/src/commands/feature.rs"
|
|
mkdir (dirname $module_path)
|
|
|
|
let content = [
|
|
"//! Feature management commands for Rustelo CLI",
|
|
"",
|
|
"use anyhow::{anyhow, Result};",
|
|
"use serde::{Deserialize, Serialize};",
|
|
"use std::collections::HashMap;",
|
|
"use std::fs;",
|
|
"use std::path::{Path, PathBuf};",
|
|
"use toml;",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct FeatureManifest {",
|
|
" pub feature: FeatureInfo,",
|
|
" pub dependencies: FeatureDependencies,",
|
|
" pub environment: Option<EnvironmentConfig>,",
|
|
" pub configuration: Option<ConfigurationFiles>,",
|
|
" pub resources: Option<ResourceFiles>,",
|
|
" pub scripts: Option<Vec<ScriptFile>>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct FeatureInfo {",
|
|
" pub name: String,",
|
|
" pub version: String,",
|
|
" pub source: String,",
|
|
" pub description: String,",
|
|
" pub requires: Option<Vec<String>>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct FeatureDependencies {",
|
|
" pub workspace: Option<Vec<String>>,",
|
|
" pub external: Option<Vec<String>>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct EnvironmentConfig {",
|
|
" pub variables: Vec<EnvVariable>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct EnvVariable {",
|
|
" pub name: String,",
|
|
" pub default: String,",
|
|
" pub required: bool,",
|
|
" pub secret: Option<bool>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct ConfigurationFiles {",
|
|
" pub files: Vec<ConfigFile>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct ConfigFile {",
|
|
" pub path: String,",
|
|
" pub template: Option<String>,",
|
|
" pub merge: Option<bool>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct ResourceFiles {",
|
|
" pub public: Option<Vec<ResourceFile>>,",
|
|
" pub site: Option<SiteResources>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct ResourceFile {",
|
|
" pub from: String,",
|
|
" pub to: String,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct SiteResources {",
|
|
" pub content: Option<Vec<ResourceFile>>,",
|
|
" pub i18n: Option<Vec<ResourceFile>>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone, Serialize, Deserialize)]",
|
|
"pub struct ScriptFile {",
|
|
" pub from: String,",
|
|
" pub to: String,",
|
|
"}",
|
|
"",
|
|
"pub struct FeatureManager {",
|
|
" pub features_path: PathBuf,",
|
|
" pub registry_path: PathBuf,",
|
|
" pub project_root: PathBuf,",
|
|
"}",
|
|
"",
|
|
"impl FeatureManager {",
|
|
" pub fn new(project_root: impl Into<PathBuf>) -> Result<Self> {",
|
|
" let project_root = project_root.into();",
|
|
" let features_path = project_root.join(\"features\");",
|
|
" let registry_path = project_root.join(\"registry\");",
|
|
" ",
|
|
" Ok(Self {",
|
|
" features_path,",
|
|
" registry_path, ",
|
|
" project_root,",
|
|
" })",
|
|
" }",
|
|
" ",
|
|
" pub fn list_available_features(&self) -> Result<Vec<String>> {",
|
|
" let registry_file = self.registry_path.join(\"features.toml\");",
|
|
" if !registry_file.exists() {",
|
|
" return Ok(vec![]);",
|
|
" }",
|
|
" ",
|
|
" let content = fs::read_to_string(®istry_file)?;",
|
|
" let registry: toml::Value = toml::from_str(&content)?;",
|
|
" ",
|
|
" let mut features = Vec::new();",
|
|
" if let Some(features_table) = registry.get(\"features\").and_then(|v| v.as_table()) {",
|
|
" for (name, _) in features_table {",
|
|
" features.push(name.clone());",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" Ok(features)",
|
|
" }",
|
|
" ",
|
|
" pub fn load_feature_manifest(&self, feature_name: &str) -> Result<FeatureManifest> {",
|
|
" let manifest_path = self.features_path.join(feature_name).join(\"feature.toml\");",
|
|
" ",
|
|
" if !manifest_path.exists() {",
|
|
" return Err(anyhow!(\"Feature '{}' not found at {}\", feature_name, manifest_path.display()));",
|
|
" }",
|
|
" ",
|
|
" let content = fs::read_to_string(&manifest_path)?;",
|
|
" let manifest: FeatureManifest = toml::from_str(&content)?;",
|
|
" ",
|
|
" Ok(manifest)",
|
|
" }",
|
|
" ",
|
|
" pub fn add_feature(&self, feature_name: &str, force: bool) -> Result<()> {",
|
|
" println!(\"🔧 Adding feature: {}\", feature_name);",
|
|
" ",
|
|
" // Load feature manifest",
|
|
" let manifest = self.load_feature_manifest(feature_name)?;",
|
|
" ",
|
|
" // Install dependencies",
|
|
" self.install_dependencies(&manifest)?;",
|
|
" ",
|
|
" // Install environment variables",
|
|
" self.install_environment(&manifest)?;",
|
|
" ",
|
|
" // Install configuration files",
|
|
" self.install_configuration(&manifest)?;",
|
|
" ",
|
|
" // Install resources",
|
|
" self.install_resources(&manifest)?;",
|
|
" ",
|
|
" // Install scripts",
|
|
" self.install_scripts(&manifest)?;",
|
|
" ",
|
|
" println!(\"✅ Feature '{}' installed successfully\", feature_name);",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn install_dependencies(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" println!(\" 📦 Installing dependencies...\");",
|
|
" ",
|
|
" // Update Cargo.toml with new dependencies",
|
|
" let cargo_toml = self.project_root.join(\"Cargo.toml\");",
|
|
" if cargo_toml.exists() {",
|
|
" // Load, modify, and save Cargo.toml",
|
|
" // Implementation would parse and update dependencies",
|
|
" println!(\" ✓ Dependencies updated in Cargo.toml\");",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn install_environment(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" if let Some(env_config) = &manifest.environment {",
|
|
" println!(\" 🔧 Installing environment configuration...\");",
|
|
" ",
|
|
" let env_file = self.project_root.join(\".env\");",
|
|
" let mut env_content = if env_file.exists() {",
|
|
" fs::read_to_string(&env_file)?",
|
|
" } else {",
|
|
" String::new()",
|
|
" };",
|
|
" ",
|
|
" // Add feature environment variables",
|
|
" env_content.push_str(&format!(\"\\n# {} Feature Environment\\n\", manifest.feature.name));",
|
|
" for var in &env_config.variables {",
|
|
" env_content.push_str(&format!(\"{}={}\\n\", var.name, var.default));",
|
|
" }",
|
|
" ",
|
|
" fs::write(&env_file, env_content)?;",
|
|
" println!(\" ✓ Environment variables added to .env\");",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn install_configuration(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" if let Some(config) = &manifest.configuration {",
|
|
" println!(\" ⚙️ Installing configuration files...\");",
|
|
" ",
|
|
" for file in &config.files {",
|
|
" let dest_path = self.project_root.join(&file.path);",
|
|
" if let Some(parent) = dest_path.parent() {",
|
|
" fs::create_dir_all(parent)?;",
|
|
" }",
|
|
" ",
|
|
" if let Some(template) = &file.template {",
|
|
" let template_path = self.features_path",
|
|
" .join(&manifest.feature.name)",
|
|
" .join(template);",
|
|
" ",
|
|
" if template_path.exists() {",
|
|
" fs::copy(&template_path, &dest_path)?;",
|
|
" println!(\" ✓ Installed config: {}\", file.path);",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn install_resources(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" if let Some(resources) = &manifest.resources {",
|
|
" println!(\" 📁 Installing resource files...\");",
|
|
" ",
|
|
" // Install public resources",
|
|
" if let Some(public_resources) = &resources.public {",
|
|
" for resource in public_resources {",
|
|
" let src_path = self.features_path",
|
|
" .join(&manifest.feature.name)",
|
|
" .join(&resource.from);",
|
|
" let dest_path = self.project_root.join(&resource.to);",
|
|
" ",
|
|
" if let Some(parent) = dest_path.parent() {",
|
|
" fs::create_dir_all(parent)?;",
|
|
" }",
|
|
" ",
|
|
" if src_path.exists() {",
|
|
" fs::copy(&src_path, &dest_path)?;",
|
|
" println!(\" ✓ Installed resource: {}\", resource.to);",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn install_scripts(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" if let Some(scripts) = &manifest.scripts {",
|
|
" println!(\" 🔨 Installing scripts...\");",
|
|
" ",
|
|
" for script in scripts {",
|
|
" let src_path = self.features_path",
|
|
" .join(&manifest.feature.name)",
|
|
" .join(&script.from);",
|
|
" let dest_path = self.project_root.join(&script.to);",
|
|
" ",
|
|
" if let Some(parent) = dest_path.parent() {",
|
|
" fs::create_dir_all(parent)?;",
|
|
" }",
|
|
" ",
|
|
" if src_path.exists() {",
|
|
" fs::copy(&src_path, &dest_path)?;",
|
|
" println!(\" ✓ Installed script: {}\", script.to);",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" pub fn remove_feature(&self, feature_name: &str, clean_deps: bool) -> Result<()> {",
|
|
" println!(\"🗑️ Removing feature: {}\", feature_name);",
|
|
" ",
|
|
" // Load feature manifest to understand what to remove",
|
|
" let manifest = self.load_feature_manifest(feature_name)?;",
|
|
" ",
|
|
" // Remove resources, configs, scripts, etc.",
|
|
" // This is a complex operation that would need careful implementation",
|
|
" ",
|
|
" println!(\"✅ Feature '{}' removed successfully\", feature_name);",
|
|
" Ok(())",
|
|
" }",
|
|
"}"
|
|
] | str join "\n"
|
|
|
|
$content | save --force $module_path
|
|
print " ✓ Feature manager module created"
|
|
}
|
|
|
|
def create_feature_installer_module [] {
|
|
let module_path = "framework/crates/rustelo-cli/src/commands/installer.rs"
|
|
|
|
let content = [
|
|
"//! Feature installer components",
|
|
"",
|
|
"use anyhow::Result;",
|
|
"use serde_json::Value;",
|
|
"use std::collections::HashMap;",
|
|
"use std::fs;",
|
|
"use std::path::{Path, PathBuf};",
|
|
"",
|
|
"use super::feature::{FeatureManifest, FeatureManager};",
|
|
"",
|
|
"pub struct FeatureInstaller {",
|
|
" pub manager: FeatureManager,",
|
|
"}",
|
|
"",
|
|
"impl FeatureInstaller {",
|
|
" pub fn new(manager: FeatureManager) -> Self {",
|
|
" Self { manager }",
|
|
" }",
|
|
" ",
|
|
" pub fn install_with_integration(&self, feature_name: &str) -> Result<()> {",
|
|
" println!(\"🚀 Installing feature '{}' with full integration...\", feature_name);",
|
|
" ",
|
|
" // Load feature manifest",
|
|
" let manifest = self.manager.load_feature_manifest(feature_name)?;",
|
|
" ",
|
|
" // Step 1: Dependencies",
|
|
" self.integrate_dependencies(&manifest)?;",
|
|
" ",
|
|
" // Step 2: Environment",
|
|
" self.integrate_environment(&manifest)?;",
|
|
" ",
|
|
" // Step 3: Configuration",
|
|
" self.integrate_configuration(&manifest)?;",
|
|
" ",
|
|
" // Step 4: Resources",
|
|
" self.integrate_resources(&manifest)?;",
|
|
" ",
|
|
" // Step 5: Node.js dependencies",
|
|
" self.integrate_node_dependencies(&manifest)?;",
|
|
" ",
|
|
" // Step 6: CSS/Styling",
|
|
" self.integrate_styling(&manifest)?;",
|
|
" ",
|
|
" // Step 7: Docker/Infrastructure",
|
|
" self.integrate_infrastructure(&manifest)?;",
|
|
" ",
|
|
" // Step 8: Scripts and Just commands",
|
|
" self.integrate_scripts(&manifest)?;",
|
|
" ",
|
|
" println!(\"✅ Feature '{}' installed with full integration\", feature_name);",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn integrate_dependencies(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" println!(\" 📦 Integrating Cargo dependencies...\");",
|
|
" ",
|
|
" let cargo_toml = self.manager.project_root.join(\"Cargo.toml\");",
|
|
" if !cargo_toml.exists() {",
|
|
" return Ok(());",
|
|
" }",
|
|
" ",
|
|
" // Load existing Cargo.toml",
|
|
" let content = fs::read_to_string(&cargo_toml)?;",
|
|
" let mut cargo_data: toml::Value = toml::from_str(&content)?;",
|
|
" ",
|
|
" // Add workspace dependencies",
|
|
" if let Some(workspace_deps) = &manifest.dependencies.workspace {",
|
|
" for dep in workspace_deps {",
|
|
" // Add to workspace.dependencies if not already present",
|
|
" println!(\" ✓ Added workspace dependency: {}\", dep);",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" // Add external dependencies",
|
|
" if let Some(external_deps) = &manifest.dependencies.external {",
|
|
" for dep in external_deps {",
|
|
" // Parse and add external dependency",
|
|
" println!(\" ✓ Added external dependency: {}\", dep);",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" // Save updated Cargo.toml",
|
|
" let updated_content = toml::to_string_pretty(&cargo_data)?;",
|
|
" fs::write(&cargo_toml, updated_content)?;",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn integrate_environment(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" println!(\" 🔧 Integrating environment variables...\");",
|
|
" ",
|
|
" if let Some(env_config) = &manifest.environment {",
|
|
" let env_file = self.manager.project_root.join(\".env\");",
|
|
" ",
|
|
" // Load existing .env or create new",
|
|
" let mut env_content = if env_file.exists() {",
|
|
" fs::read_to_string(&env_file)?",
|
|
" } else {",
|
|
" String::from(\"# Rustelo Feature Environment\\n\")",
|
|
" };",
|
|
" ",
|
|
" // Add feature-specific environment section",
|
|
" env_content.push_str(&format!(\"\\n# {} Feature\\n\", manifest.feature.name.to_uppercase()));",
|
|
" ",
|
|
" for var in &env_config.variables {",
|
|
" if var.secret.unwrap_or(false) {",
|
|
" env_content.push_str(&format!(\"# {}: {} (REQUIRED - KEEP SECRET)\\n\", var.name, var.name));",
|
|
" env_content.push_str(&format!(\"{}=\\n\", var.name));",
|
|
" } else {",
|
|
" let required = if var.required { \" (REQUIRED)\" } else { \"\" };",
|
|
" env_content.push_str(&format!(\"# {}: {}{} \\n\", var.name, var.name, required));",
|
|
" env_content.push_str(&format!(\"{}={}\\n\", var.name, var.default));",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" fs::write(&env_file, env_content)?;",
|
|
" println!(\" ✓ Environment variables integrated\");",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn integrate_configuration(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" println!(\" ⚙️ Integrating configuration files...\");",
|
|
" ",
|
|
" if let Some(config) = &manifest.configuration {",
|
|
" for file in &config.files {",
|
|
" let dest_path = self.manager.project_root.join(&file.path);",
|
|
" ",
|
|
" // Create directory if it doesn't exist",
|
|
" if let Some(parent) = dest_path.parent() {",
|
|
" fs::create_dir_all(parent)?;",
|
|
" }",
|
|
" ",
|
|
" if let Some(template) = &file.template {",
|
|
" let template_path = self.manager.features_path",
|
|
" .join(&manifest.feature.name)",
|
|
" .join(template);",
|
|
" ",
|
|
" if template_path.exists() {",
|
|
" if file.merge.unwrap_or(false) && dest_path.exists() {",
|
|
" // Merge configuration files (TOML/JSON)",
|
|
" self.merge_config_file(&template_path, &dest_path)?;",
|
|
" } else {",
|
|
" // Simple copy",
|
|
" fs::copy(&template_path, &dest_path)?;",
|
|
" }",
|
|
" println!(\" ✓ Integrated config: {}\", file.path);",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn merge_config_file(&self, template_path: &Path, dest_path: &Path) -> Result<()> {",
|
|
" // Implementation for merging TOML/JSON configuration files",
|
|
" // This would be complex logic to merge configs intelligently",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn integrate_resources(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" println!(\" 📁 Integrating resources...\");",
|
|
" ",
|
|
" if let Some(resources) = &manifest.resources {",
|
|
" // Integrate public assets",
|
|
" if let Some(public) = &resources.public {",
|
|
" for resource in public {",
|
|
" let src_path = self.manager.features_path",
|
|
" .join(&manifest.feature.name)",
|
|
" .join(&resource.from);",
|
|
" let dest_path = self.manager.project_root.join(&resource.to);",
|
|
" ",
|
|
" if let Some(parent) = dest_path.parent() {",
|
|
" fs::create_dir_all(parent)?;",
|
|
" }",
|
|
" ",
|
|
" if src_path.exists() {",
|
|
" fs::copy(&src_path, &dest_path)?;",
|
|
" println!(\" ✓ Integrated resource: {}\", resource.to);",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" // Integrate site resources",
|
|
" if let Some(site) = &resources.site {",
|
|
" if let Some(content) = &site.content {",
|
|
" for resource in content {",
|
|
" let src_path = self.manager.features_path",
|
|
" .join(&manifest.feature.name)",
|
|
" .join(&resource.from);",
|
|
" let dest_path = self.manager.project_root.join(&resource.to);",
|
|
" ",
|
|
" if let Some(parent) = dest_path.parent() {",
|
|
" fs::create_dir_all(parent)?;",
|
|
" }",
|
|
" ",
|
|
" if src_path.exists() {",
|
|
" fs::copy(&src_path, &dest_path)?;",
|
|
" println!(\" ✓ Integrated site content: {}\", resource.to);",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn integrate_node_dependencies(&self, _manifest: &FeatureManifest) -> Result<()> {",
|
|
" println!(\" 📦 Integrating Node.js dependencies...\");",
|
|
" ",
|
|
" let package_json = self.manager.project_root.join(\"package.json\");",
|
|
" if package_json.exists() {",
|
|
" // Update package.json with feature dependencies",
|
|
" println!(\" ✓ Node.js dependencies integrated\");",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn integrate_styling(&self, _manifest: &FeatureManifest) -> Result<()> {",
|
|
" println!(\" 🎨 Integrating styling...\");",
|
|
" ",
|
|
" let uno_config = self.manager.project_root.join(\"uno.config.ts\");",
|
|
" if uno_config.exists() {",
|
|
" // Update UnoCSS configuration with feature presets",
|
|
" println!(\" ✓ Styling integrated\");",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn integrate_infrastructure(&self, _manifest: &FeatureManifest) -> Result<()> {",
|
|
" println!(\" 🐳 Integrating infrastructure...\");",
|
|
" ",
|
|
" let docker_compose = self.manager.project_root.join(\"docker-compose.yml\");",
|
|
" if docker_compose.exists() {",
|
|
" // Update docker-compose with feature services",
|
|
" println!(\" ✓ Infrastructure integrated\");",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn integrate_scripts(&self, manifest: &FeatureManifest) -> Result<()> {",
|
|
" println!(\" 🔨 Integrating scripts...\");",
|
|
" ",
|
|
" if let Some(scripts) = &manifest.scripts {",
|
|
" for script in scripts {",
|
|
" let src_path = self.manager.features_path",
|
|
" .join(&manifest.feature.name)",
|
|
" .join(&script.from);",
|
|
" let dest_path = self.manager.project_root.join(&script.to);",
|
|
" ",
|
|
" if let Some(parent) = dest_path.parent() {",
|
|
" fs::create_dir_all(parent)?;",
|
|
" }",
|
|
" ",
|
|
" if src_path.exists() {",
|
|
" fs::copy(&src_path, &dest_path)?;",
|
|
" println!(\" ✓ Integrated script: {}\", script.to);",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" // Update justfile with feature commands",
|
|
" let justfile = self.manager.project_root.join(\"justfile\");",
|
|
" if justfile.exists() {",
|
|
" // Add feature-specific just commands",
|
|
" println!(\" ✓ Just commands integrated\");",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
"}"
|
|
] | str join "\n"
|
|
|
|
$content | save --force $module_path
|
|
print " ✓ Feature installer module created"
|
|
}
|
|
|
|
def create_dependency_resolver_module [] {
|
|
let module_path = "framework/crates/rustelo-cli/src/commands/resolver.rs"
|
|
|
|
let content = [
|
|
"//! Feature dependency resolver",
|
|
"",
|
|
"use anyhow::{anyhow, Result};",
|
|
"use std::collections::{HashMap, HashSet, VecDeque};",
|
|
"",
|
|
"use super::feature::{FeatureManifest, FeatureManager};",
|
|
"",
|
|
"#[derive(Debug, Clone)]",
|
|
"pub struct DependencyGraph {",
|
|
" pub nodes: HashMap<String, FeatureNode>,",
|
|
" pub edges: HashMap<String, Vec<String>>,",
|
|
"}",
|
|
"",
|
|
"#[derive(Debug, Clone)]",
|
|
"pub struct FeatureNode {",
|
|
" pub name: String,",
|
|
" pub version: String,",
|
|
" pub installed: bool,",
|
|
" pub requires: Vec<String>,",
|
|
"}",
|
|
"",
|
|
"pub struct DependencyResolver {",
|
|
" manager: FeatureManager,",
|
|
"}",
|
|
"",
|
|
"impl DependencyResolver {",
|
|
" pub fn new(manager: FeatureManager) -> Self {",
|
|
" Self { manager }",
|
|
" }",
|
|
" ",
|
|
" pub fn resolve_dependencies(&self, feature_name: &str) -> Result<Vec<String>> {",
|
|
" println!(\"🔍 Resolving dependencies for '{}'...\", feature_name);",
|
|
" ",
|
|
" // Build dependency graph",
|
|
" let graph = self.build_dependency_graph(feature_name)?;",
|
|
" ",
|
|
" // Check for circular dependencies",
|
|
" self.check_circular_dependencies(&graph)?;",
|
|
" ",
|
|
" // Topological sort for installation order",
|
|
" let install_order = self.topological_sort(&graph)?;",
|
|
" ",
|
|
" println!(\" ✓ Dependencies resolved: {:?}\", install_order);",
|
|
" Ok(install_order)",
|
|
" }",
|
|
" ",
|
|
" fn build_dependency_graph(&self, root_feature: &str) -> Result<DependencyGraph> {",
|
|
" let mut graph = DependencyGraph {",
|
|
" nodes: HashMap::new(),",
|
|
" edges: HashMap::new(),",
|
|
" };",
|
|
" ",
|
|
" let mut to_process = VecDeque::new();",
|
|
" let mut processed = HashSet::new();",
|
|
" ",
|
|
" to_process.push_back(root_feature.to_string());",
|
|
" ",
|
|
" while let Some(current_feature) = to_process.pop_front() {",
|
|
" if processed.contains(¤t_feature) {",
|
|
" continue;",
|
|
" }",
|
|
" ",
|
|
" processed.insert(current_feature.clone());",
|
|
" ",
|
|
" // Load feature manifest",
|
|
" let manifest = self.manager.load_feature_manifest(¤t_feature)?;",
|
|
" ",
|
|
" let requires = manifest.feature.requires.unwrap_or_default();",
|
|
" ",
|
|
" // Add node to graph",
|
|
" graph.nodes.insert(",
|
|
" current_feature.clone(),",
|
|
" FeatureNode {",
|
|
" name: current_feature.clone(),",
|
|
" version: manifest.feature.version,",
|
|
" installed: false, // Would check if actually installed",
|
|
" requires: requires.clone(),",
|
|
" },",
|
|
" );",
|
|
" ",
|
|
" // Add edges",
|
|
" graph.edges.insert(current_feature.clone(), requires.clone());",
|
|
" ",
|
|
" // Add dependencies to process queue",
|
|
" for dep in requires {",
|
|
" if !processed.contains(&dep) {",
|
|
" to_process.push_back(dep);",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" Ok(graph)",
|
|
" }",
|
|
" ",
|
|
" fn check_circular_dependencies(&self, graph: &DependencyGraph) -> Result<()> {",
|
|
" // Implement cycle detection algorithm (DFS-based)",
|
|
" let mut white = HashSet::new();",
|
|
" let mut gray = HashSet::new();",
|
|
" let mut black = HashSet::new();",
|
|
" ",
|
|
" // Initialize all nodes as white (unvisited)",
|
|
" for node_name in graph.nodes.keys() {",
|
|
" white.insert(node_name.clone());",
|
|
" }",
|
|
" ",
|
|
" // Check each node",
|
|
" for node_name in graph.nodes.keys() {",
|
|
" if white.contains(node_name) {",
|
|
" if self.has_cycle_dfs(node_name, graph, &mut white, &mut gray, &mut black)? {",
|
|
" return Err(anyhow!(\"Circular dependency detected involving '{}'.\", node_name));",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" Ok(())",
|
|
" }",
|
|
" ",
|
|
" fn has_cycle_dfs(",
|
|
" &self,",
|
|
" node: &str,",
|
|
" graph: &DependencyGraph,",
|
|
" white: &mut HashSet<String>,",
|
|
" gray: &mut HashSet<String>,",
|
|
" black: &mut HashSet<String>,",
|
|
" ) -> Result<bool> {",
|
|
" // Move node from white to gray",
|
|
" white.remove(node);",
|
|
" gray.insert(node.to_string());",
|
|
" ",
|
|
" // Check all dependencies",
|
|
" if let Some(dependencies) = graph.edges.get(node) {",
|
|
" for dep in dependencies {",
|
|
" if gray.contains(dep) {",
|
|
" // Back edge found - cycle detected",
|
|
" return Ok(true);",
|
|
" }",
|
|
" ",
|
|
" if white.contains(dep)",
|
|
" && self.has_cycle_dfs(dep, graph, white, gray, black)?",
|
|
" {",
|
|
" return Ok(true);",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" // Move node from gray to black",
|
|
" gray.remove(node);",
|
|
" black.insert(node.to_string());",
|
|
" ",
|
|
" Ok(false)",
|
|
" }",
|
|
" ",
|
|
" fn topological_sort(&self, graph: &DependencyGraph) -> Result<Vec<String>> {",
|
|
" let mut in_degree = HashMap::new();",
|
|
" let mut result = Vec::new();",
|
|
" let mut queue = VecDeque::new();",
|
|
" ",
|
|
" // Initialize in-degree count",
|
|
" for node_name in graph.nodes.keys() {",
|
|
" in_degree.insert(node_name.clone(), 0);",
|
|
" }",
|
|
" ",
|
|
" // Calculate in-degrees",
|
|
" for (_node, dependencies) in &graph.edges {",
|
|
" for dep in dependencies {",
|
|
" *in_degree.entry(dep.clone()).or_insert(0) += 1;",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" // Find nodes with no incoming edges",
|
|
" for (node, degree) in &in_degree {",
|
|
" if *degree == 0 {",
|
|
" queue.push_back(node.clone());",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" // Process queue",
|
|
" while let Some(current) = queue.pop_front() {",
|
|
" result.push(current.clone());",
|
|
" ",
|
|
" // Reduce in-degree for all dependents",
|
|
" for (node, dependencies) in &graph.edges {",
|
|
" if dependencies.contains(¤t) {",
|
|
" let degree = in_degree.get_mut(node).unwrap();",
|
|
" *degree -= 1;",
|
|
" if *degree == 0 {",
|
|
" queue.push_back(node.clone());",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" }",
|
|
" ",
|
|
" // Check if all nodes are processed (no cycles)",
|
|
" if result.len() != graph.nodes.len() {",
|
|
" return Err(anyhow!(\"Dependency cycle detected - cannot resolve installation order\"));",
|
|
" }",
|
|
" ",
|
|
" Ok(result)",
|
|
" }",
|
|
" ",
|
|
" pub fn check_conflicts(&self, features: &[String]) -> Result<Vec<String>> {",
|
|
" let mut conflicts = Vec::new();",
|
|
" ",
|
|
" // Check for conflicting features",
|
|
" // This would involve loading feature manifests and checking for conflicts",
|
|
" ",
|
|
" Ok(conflicts)",
|
|
" }",
|
|
"}"
|
|
] | str join "\n"
|
|
|
|
$content | save --force $module_path
|
|
print " ✓ Dependency resolver module created"
|
|
}
|
|
|
|
def implement_feature_installer [] {
|
|
print "🔧 Implementing feature installer components..."
|
|
|
|
# Create enhanced feature manifest structure for analytics
|
|
create_enhanced_analytics_manifest
|
|
|
|
# Create enhanced feature manifest for smart-build
|
|
create_enhanced_smart_build_manifest
|
|
|
|
print " ✓ Feature installer components implemented"
|
|
}
|
|
|
|
def create_enhanced_analytics_manifest [] {
|
|
let manifest_path = "features/analytics/feature.toml"
|
|
|
|
let enhanced_content = [
|
|
"[feature]",
|
|
"name = \"analytics\"",
|
|
"version = \"0.1.0\"",
|
|
"source = \"p-jpl-website\"",
|
|
"description = \"Comprehensive analytics system with navigation tracking, server monitoring, and browser analytics\"",
|
|
"requires = []",
|
|
"",
|
|
"[dependencies]",
|
|
"workspace = [\"chrono\", \"serde_json\", \"prometheus\", \"futures\", \"tokio\"]",
|
|
"external = [\"ratatui = '0.29'\", \"inquire = '0.7'\", \"crossterm = '0.29'\", \"lru = '0.16'\"]",
|
|
"",
|
|
"[[environment.variables]]",
|
|
"name = \"ANALYTICS_ENABLED\"",
|
|
"default = \"true\"",
|
|
"required = false",
|
|
"",
|
|
"[[environment.variables]]",
|
|
"name = \"ANALYTICS_LOG_PATH\"",
|
|
"default = \"logs/analytics\"",
|
|
"required = false",
|
|
"",
|
|
"[[environment.variables]]",
|
|
"name = \"ANALYTICS_API_KEY\"",
|
|
"default = \"\"",
|
|
"required = true",
|
|
"secret = true",
|
|
"",
|
|
"[configuration]",
|
|
"files = [",
|
|
" { path = \"config/analytics.toml\", template = \"templates/analytics.config.toml\" },",
|
|
" { path = \"config/routes/analytics.toml\", template = \"templates/analytics.routes.toml\", merge = true }",
|
|
"]",
|
|
"",
|
|
"[resources]",
|
|
"public = [",
|
|
" { from = \"assets/analytics.js\", to = \"public/js/analytics.js\" },",
|
|
" { from = \"assets/analytics.wasm\", to = \"public/wasm/analytics.wasm\" }",
|
|
"]",
|
|
"",
|
|
"[resources.site]",
|
|
"content = [",
|
|
" { from = \"content/docs/analytics.md\", to = \"site/content/docs/analytics.md\" }",
|
|
"]",
|
|
"i18n = [",
|
|
" { from = \"i18n/en/analytics.ftl\", to = \"site/i18n/en/analytics.ftl\" },",
|
|
" { from = \"i18n/es/analytics.ftl\", to = \"site/i18n/es/analytics.ftl\" }",
|
|
"]",
|
|
"",
|
|
"[node]",
|
|
"dependencies = { \"@analytics/cli\" = \"^1.0.0\" }",
|
|
"",
|
|
"[styles]",
|
|
"uno = { presets = [\"@analytics/preset\"] }",
|
|
"",
|
|
"[docker]",
|
|
"compose = { services = [{ file = \"docker/analytics-service.yml\", merge = true }] }",
|
|
"",
|
|
"[[scripts]]",
|
|
"from = \"scripts/analytics-report.nu\"",
|
|
"to = \"scripts/analytics/report.nu\"",
|
|
"",
|
|
"[[scripts]]",
|
|
"from = \"scripts/analytics-dashboard.nu\"",
|
|
"to = \"scripts/analytics/dashboard.nu\"",
|
|
"",
|
|
"[just]",
|
|
"module = \"just/analytics.just\""
|
|
] | str join "\n"
|
|
|
|
$enhanced_content | save --force $manifest_path
|
|
print " ✓ Enhanced analytics manifest created"
|
|
}
|
|
|
|
def create_enhanced_smart_build_manifest [] {
|
|
let manifest_path = "features/smart-build/feature.toml"
|
|
|
|
let enhanced_content = [
|
|
"[feature]",
|
|
"name = \"smart-build\"",
|
|
"version = \"0.1.0\"",
|
|
"source = \"p-jpl-website\"",
|
|
"description = \"Incremental build system with intelligent caching and performance optimization\"",
|
|
"requires = []",
|
|
"",
|
|
"[dependencies]",
|
|
"workspace = [\"notify\", \"lru\", \"futures\", \"walkdir\", \"ignore\"]",
|
|
"external = [\"blake3 = '1.5'\", \"rayon = '1.10'\"]",
|
|
"",
|
|
"[[environment.variables]]",
|
|
"name = \"SMART_BUILD_CACHE_DIR\"",
|
|
"default = \".cache/smart-build\"",
|
|
"required = false",
|
|
"",
|
|
"[[environment.variables]]",
|
|
"name = \"SMART_BUILD_PARALLEL_JOBS\"",
|
|
"default = \"auto\"",
|
|
"required = false",
|
|
"",
|
|
"[[environment.variables]]",
|
|
"name = \"SMART_BUILD_MAX_CACHE_SIZE\"",
|
|
"default = \"1GB\"",
|
|
"required = false",
|
|
"",
|
|
"[configuration]",
|
|
"files = [",
|
|
" { path = \"config/smart-build.toml\", template = \"templates/smart-build.config.toml\" }",
|
|
"]",
|
|
"",
|
|
"[resources]",
|
|
"public = [",
|
|
" { from = \"assets/build-progress.js\", to = \"public/js/build-progress.js\" }",
|
|
"]",
|
|
"",
|
|
"[[scripts]]",
|
|
"from = \"scripts/smart-build-clean.nu\"",
|
|
"to = \"scripts/build/clean.nu\"",
|
|
"",
|
|
"[[scripts]]",
|
|
"from = \"scripts/smart-build-stats.nu\"",
|
|
"to = \"scripts/build/stats.nu\"",
|
|
"",
|
|
"[just]",
|
|
"module = \"just/smart-build.just\""
|
|
] | str join "\n"
|
|
|
|
$enhanced_content | save --force $manifest_path
|
|
print " ✓ Enhanced smart-build manifest created"
|
|
}
|
|
|
|
def create_dependency_resolver [] {
|
|
print "🔍 Creating dependency resolver..."
|
|
|
|
# The resolver module was already created above
|
|
print " ✓ Dependency resolver created"
|
|
}
|
|
|
|
def create_feature_templates [] {
|
|
print "📋 Creating feature templates..."
|
|
|
|
# Create template directory structure
|
|
mkdir features/analytics/templates
|
|
mkdir features/analytics/assets
|
|
mkdir features/analytics/scripts
|
|
mkdir features/analytics/i18n/en
|
|
mkdir features/analytics/i18n/es
|
|
|
|
mkdir features/smart-build/templates
|
|
mkdir features/smart-build/assets
|
|
mkdir features/smart-build/scripts
|
|
|
|
# Create analytics configuration template
|
|
let analytics_config = [
|
|
"[analytics]",
|
|
"enabled = true",
|
|
"log_path = \"logs/analytics\"",
|
|
"max_events_in_memory = 1000",
|
|
"",
|
|
"[analytics.navigation]",
|
|
"track_clicks = true",
|
|
"track_route_changes = true",
|
|
"slow_resolution_threshold_ms = 10",
|
|
"",
|
|
"[analytics.server]",
|
|
"track_panics = true",
|
|
"track_errors = true",
|
|
"performance_monitoring = true",
|
|
"",
|
|
"[analytics.browser]",
|
|
"track_console_errors = true",
|
|
"track_performance = true",
|
|
"track_user_interactions = false"
|
|
] | str join "\n"
|
|
|
|
$analytics_config | save --force "features/analytics/templates/analytics.config.toml"
|
|
|
|
# Create smart-build configuration template
|
|
let smart_build_config = [
|
|
"[smart-build]",
|
|
"enabled = true",
|
|
"cache_dir = \".cache/smart-build\"",
|
|
"parallel_jobs = \"auto\"",
|
|
"max_cache_size = \"1GB\"",
|
|
"",
|
|
"[smart-build.caching]",
|
|
"l1_cache_size = 100",
|
|
"l2_cache_size = 500",
|
|
"l3_cache_size = 1000",
|
|
"ttl_seconds = 3600",
|
|
"",
|
|
"[smart-build.optimization]",
|
|
"incremental_builds = true",
|
|
"smart_recompilation = true",
|
|
"dependency_tracking = true"
|
|
] | str join "\n"
|
|
|
|
$smart_build_config | save --force "features/smart-build/templates/smart-build.config.toml"
|
|
|
|
print " ✓ Feature templates created"
|
|
} |