xypriss 9.0.13 → 9.1.1

package/tools/xyp/scripts/build.js

@@ -0,0 +1,123 @@
+const { execSync } = require("child_process");
+const fs = require("fs");
+const path = require("path");
+const os = require("os");
+
+// *****************************************************************************
+// Nehonix XyPriss Git Release Builder
+// *****************************************************************************
+
+const BIN_NAME = "xfpm";
+const PROJECT_ROOT = path.dirname(__dirname);
+const OUTPUT_DIR = path.join(PROJECT_ROOT, "dist");
+const BIN_DIR = path.join(PROJECT_ROOT, "bin");
+
+const TARGETS = [
+    {
+        target: "x86_64-unknown-linux-gnu",
+        suffix: "linux-amd64",
+        ext: "",
+        features: "mimalloc",
+    },
+    {
+        target: "x86_64-unknown-linux-musl",
+        suffix: "linux-amd64-musl",
+        ext: "",
+        features: "mimalloc",
+    },
+    {
+        target: "aarch64-unknown-linux-gnu",
+        suffix: "linux-arm64",
+        ext: "",
+        features: "mimalloc",
+    },
+    {
+        target: "x86_64-apple-darwin",
+        suffix: "darwin-amd64",
+        ext: "",
+        features: "",
+    },
+    {
+        target: "aarch64-apple-darwin",
+        suffix: "darwin-arm64",
+        ext: "",
+        features: "",
+    },
+    {
+        target: "x86_64-pc-windows-gnu",
+        suffix: "windows-amd64",
+        ext: ".exe",
+        features: "mimalloc",
+    },
+    {
+        target: "aarch64-pc-windows-gnullvm",
+        suffix: "windows-arm64",
+        ext: ".exe",
+        features: "mimalloc",
+    },
+];
+
+const colors = {
+    reset: "\x1b[0m",
+    red: "\x1b[31m",
+    green: "\x1b[32m",
+    blue: "\x1b[34m",
+};
+function print_status(msg) {
+    console.log(`${colors.blue}[INFO]${colors.reset} ${msg}`);
+}
+function print_success(msg) {
+    console.log(`${colors.green}[SUCCESS]${colors.reset} ${msg}`);
+}
+function print_error(msg) {
+    console.log(`${colors.red}[ERROR]${colors.reset} ${msg}`);
+}
+
+if (!fs.existsSync(OUTPUT_DIR)) fs.mkdirSync(OUTPUT_DIR, { recursive: true });
+if (!fs.existsSync(BIN_DIR)) fs.mkdirSync(BIN_DIR, { recursive: true });
+
+const ZIG_BIN = path.join(PROJECT_ROOT, "zig-bin");
+const customEnv = { ...process.env, RUSTFLAGS: "-C link-arg=-s" };
+if (fs.existsSync(ZIG_BIN)) {
+    customEnv.PATH = `${ZIG_BIN}${path.delimiter}${process.env.PATH}`;
+}
+
+print_status("🚀 Starting Release Build process...");
+
+for (const { target, suffix, ext, features } of TARGETS) {
+    const targetFile = `${BIN_NAME}-${suffix}${ext}`;
+    const destPath = path.join(OUTPUT_DIR, targetFile);
+
+    print_status(`Building ${targetFile}...`);
+
+    try {
+        const featureFlag = features
+            ? `--features ${features}`
+            : "--no-default-features";
+        // On limite les JOBS pour éviter de saturer la RAM sur les grosses cibles
+        execSync(
+            `cargo zigbuild --release --target ${target} ${featureFlag} --jobs 4`,
+            {
+                stdio: "inherit",
+                env: customEnv,
+            },
+        );
+
+        const buildArtifact = path.join(
+            PROJECT_ROOT,
+            "target",
+            target,
+            "release",
+            `${BIN_NAME}${ext}`,
+        );
+        if (fs.existsSync(buildArtifact)) {
+            fs.copyFileSync(buildArtifact, destPath);
+            print_success(`Built: ${targetFile}`);
+        }
+    } catch (e) {
+        print_error(`Failed ${target}.`);
+    }
+}
+
+print_success("\n✅ RELEASE READY. Binaries are in: " + OUTPUT_DIR);
+

package/tools/xyp/scripts/build.sh

@@ -0,0 +1,85 @@
+#!/bin/bash
+# *****************************************************************************
+# Nehonix XyPriss Build Script - xfpm
+# PROFESSIONAL CROSS-PLATFORM BUILDER
+# *****************************************************************************
+
+set -e
+
+# Base directory for the xyp tool
+SCRIPT_DIR="$(cd "$(dirname "${BASH_SOURCE[0]}")" && pwd)"
+PROJECT_ROOT="$(dirname "$SCRIPT_DIR")"
+cd "$PROJECT_ROOT"
+
+OUTPUT_DIR="$PROJECT_ROOT/dist"
+mkdir -p "$OUTPUT_DIR"
+
+# Auto-detect zig-bin
+ZIG_BIN="$PROJECT_ROOT/zig-bin"
+if [ -d "$ZIG_BIN" ]; then
+    export PATH="$ZIG_BIN:$PATH"
+fi
+
+# Colors for output
+RED='\033[0;31m'
+GREEN='\033[0;32m'
+YELLOW='\033[1;33m'
+BLUE='\033[0;34m'
+NC='\033[0m' # No Color
+
+print_status() { echo -e "${BLUE}[INFO]${NC} $1"; }
+print_success() { echo -e "${GREEN}[SUCCESS]${NC} $1"; }
+print_error() { echo -e "${RED}[ERROR]${NC} $1"; }
+print_warning() { echo -e "${YELLOW}[WARNING]${NC} $1"; }
+
+# Targets to build
+# Format: "rust-target|output-suffix|binary-extension|features"
+TARGETS=(
+    "x86_64-unknown-linux-gnu|linux-amd64||mimalloc"
+    "x86_64-unknown-linux-musl|linux-amd64-musl||mimalloc"
+    "aarch64-unknown-linux-gnu|linux-arm64||mimalloc"
+    "x86_64-pc-windows-gnu|windows-amd64|.exe|mimalloc"
+    "aarch64-pc-windows-gnullvm|windows-arm64|.exe|mimalloc"
+    "x86_64-apple-darwin|darwin-amd64||"
+    "aarch64-apple-darwin|darwin-arm64||"
+)
+
+echo -e "${BLUE}🚀 Starting XyPriss Multi-Platform Build...${NC}\n"
+
+# 1. Host platform build (Fastest access for local dev)
+print_status "Building for host platform..."
+if cargo build --release; then
+    mkdir -p bin
+    cp target/release/xfpm bin/xfpm
+    print_success "Host binary saved to bin/xfpm"
+else
+    print_error "Host build failed"
+fi
+
+# 2. Cross-platform builds
+for ENTRY in "${TARGETS[@]}"; do
+    IFS='|' read -r RUST_TARGET SUFFIX EXT FEATURES <<< "$ENTRY"
+    TARGET_FILE="xfpm-${SUFFIX}${EXT}"
+    DEST_PATH="$OUTPUT_DIR/$TARGET_FILE"
+
+    FEATURE_FLAG="--no-default-features"
+    if [ ! -z "$FEATURES" ]; then
+        FEATURE_FLAG="--features $FEATURES"
+    fi
+
+    echo "----------------------------------------------------"
+    print_status "Building for $RUST_TARGET ($FEATURE_FLAG)..."
+
+    # On utilise --jobs 4 pour ne pas saturer le CPU/RAM en parallèle
+    if RUSTFLAGS="-C link-arg=-s" cargo zigbuild --target "$RUST_TARGET" --release --jobs 4 $FEATURE_FLAG; then
+        cp "target/$RUST_TARGET/release/xfpm${EXT}" "$DEST_PATH"
+        print_success "Successfully built and copied: $TARGET_FILE"
+    else
+        print_error "Failed to build for $RUST_TARGET"
+        # On ne s'arrête pas pour permettre aux autres targets de finir
+    fi
+done
+
+echo -e "\n${GREEN}✅ Build process finished.${NC}"
+print_status "Binaries are located in: $OUTPUT_DIR"
+ls -lh "$OUTPUT_DIR"

package/tools/xyp/src/commands/exec.rs

@@ -0,0 +1,113 @@
+use std::process::Command;
+use colored::Colorize;
+use anyhow::{Result, Context};
+
+pub async fn run(command: String, args: Vec<String>) -> Result<()> {
+    // 0. Split command for binary name vs package spec (e.g. create-vite@latest -> bin: create-vite, pkg: create-vite@latest)
+    let (pkg_spec, bin_name) = if let Some(idx) = command.rfind('@') {
+        if idx > 0 {
+            (command.clone(), command[..idx].to_string())
+        } else {
+            (command.clone(), command.clone())
+        }
+    } else {
+        (command.clone(), command.clone())
+    };
+
+    // 1. Resolve the binary path
+    // Priority: 
+    // a) node_modules/.bin/<bin_name>
+    // b) System PATH (fallback like npx)
+    
+    let current_dir = std::env::current_dir()?;
+    let mut bin_path = None;
+    
+    // 1. Search for node_modules/.bin in current and parent directories
+    let mut check_dir = Some(current_dir.as_path());
+    while let Some(dir) = check_dir {
+        let local_bin = dir.join("node_modules").join(".bin").join(&bin_name);
+        if local_bin.exists() {
+            bin_path = Some(local_bin);
+            break;
+        }
+        check_dir = dir.parent();
+    }
+    
+    let bin_path = if let Some(path) = bin_path {
+        path
+    } else {
+        // Fallback to searching in PATH
+        match which::which(&bin_name) {
+            Ok(path) => path,
+            Err(_) => {
+                // If not found, try to find it in .xpm_global/bin
+                let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
+                let global_bin = std::path::Path::new(&home).join(".xpm_global").join("bin").join(&bin_name);
+                
+                if global_bin.exists() {
+                    global_bin
+                } else {
+                    // 1.c) Auto-install if not found (npx-like behavior)
+                    println!("{} Command {} not found. Attempting to install automatically...", "⚙".bold().blue(), bin_name.bold());
+                    
+                    // Try to install the package (assuming package name == command name)
+                    // We install it globally to make it available for future use
+                    if let Err(e) = crate::commands::install::run(
+                        vec![pkg_spec.clone()], 
+                        false, 
+                        3, 
+                        true, // global
+                        false, 
+                        false, 
+                        false, 
+                        false, 
+                        false,
+                        false
+                    ).await {
+                        println!("{} Failed to auto-install package {}: {}", "×".bold().red(), command.bold(), e);
+                        return Err(anyhow::anyhow!("Command not found and auto-install failed: {}", command));
+                    }
+
+                    // Re-check after installation
+                    let global_bin_check = std::path::Path::new(&home).join(".xpm_global").join("bin").join(&bin_name);
+                    if global_bin_check.exists() {
+                        global_bin_check
+                    } else { 
+                        // Special case: package installed but doesn't have a binary matching the command name
+                        // Check if it's tailwindcss v4 specifically to help the user
+                        if bin_name == "tailwindcss" {
+                            println!("{} Package {} (v4) installed but it no longer contains a CLI.", "!".bold().yellow(), "tailwindcss".bold());
+                            println!("   {} Suggestion: Use {} instead.", "→".dimmed(), "xfpm install -g @tailwindcss/cli".cyan());
+                            println!("   {} Then run: {}", "→".dimmed(), "xfpm -- @tailwindcss/cli ...".cyan());
+                        }
+
+                        println!("{} Command {} still not found after installing package {}.", "×".bold().red(), bin_name.bold(), pkg_spec.bold());
+                        println!("   {} Note: The package may not contain an executable named {}.", "→".dimmed(), bin_name.cyan());
+                        return Err(anyhow::anyhow!("Command not found: {}", bin_name));
+                    }
+                }
+            }
+        }
+    };
+
+    let pb = indicatif::ProgressBar::new_spinner();
+    pb.set_style(indicatif::ProgressStyle::default_spinner().template("{spinner:.magenta} Executing {msg}").unwrap());
+    pb.set_message(format!("{}", bin_name.bold().magenta()));
+    pb.enable_steady_tick(std::time::Duration::from_millis(80));
+
+    // 2. Execute
+    let mut cmd = Command::new(bin_path);
+    cmd.args(&args);
+    
+    // Clear spinner before exec
+    pb.finish_and_clear();
+
+    let status = cmd.status().context(format!("Failed to execute {}", bin_name))?;
+
+    if !status.success() {
+        let code = status.code().unwrap_or(1);
+        std::process::exit(code);
+    }
+
+    Ok(())
+}

package/tools/xyp/src/commands/init.rs

@@ -0,0 +1,378 @@
+use std::path::{Path, PathBuf};
+
+use colored::Colorize;
+use anyhow::{Result, Context, anyhow};
+use dialoguer::{Input, Select, theme::ColorfulTheme};
+use serde_json::Value;
+use std::fs::File;
+use indicatif::{ProgressBar, ProgressStyle};
+
+const TEMPLATE_URL: &str = "https://dll.nehonix.com/dl/mds/xypriss/templates/initdr.zip";
+
+pub struct InitOptions {
+    pub name: Option<String>,
+    pub desc: Option<String>,
+    pub lang: Option<String>,
+    pub port: Option<u16>,
+    pub author: Option<String>,
+    pub alias: Option<String>,
+}
+
+pub async fn run(opts: InitOptions) -> Result<()> {
+    let start_time = std::time::Instant::now();
+    // 1. Get Project Name
+    let name = match opts.name.clone() {
+        Some(n) => n,
+        None => Input::with_theme(&ColorfulTheme::default())
+            .with_prompt("Project name")
+            .default("my-xypriss-app".to_string())
+            .interact_text()?
+    };
+
+    let target_dir = std::env::current_dir()?.join(&name);
+    
+    // Handle existing directory
+    if target_dir.exists() {
+        let options = vec!["Overwrite (Delete existing)", "Cancel"];
+        let selection = Select::with_theme(&ColorfulTheme::default())
+            .with_prompt(format!("Directory '{}' already exists", name))
+            .default(0)
+            .items(&options)
+            .interact()?;
+
+        if selection == 1 {
+            println!("Operation cancelled.");
+            return Ok(());
+        }
+        
+        // Delete existing directory
+        let pb = ProgressBar::new_spinner();
+        pb.set_style(ProgressStyle::default_spinner().template("{spinner:.red} Removing existing directory...").unwrap());
+        pb.enable_steady_tick(std::time::Duration::from_millis(80));
+        std::fs::remove_dir_all(&target_dir)?;
+        pb.finish_and_clear();
+    }
+
+    // 2. Select Language
+    let lang_folder = match opts.lang.as_deref() {
+        Some("ts") | Some("typescript") => "TS",
+        Some("js") | Some("javascript") => "JS",
+        Some(_) => "TS", 
+        None => {
+            let languages = vec!["TypeScript", "JavaScript"];
+            let selection = Select::with_theme(&ColorfulTheme::default())
+                .with_prompt("Select language")
+                .default(0)
+                .items(&languages)
+                .interact()?;
+            if selection == 0 { "TS" } else { "JS" }
+        }
+    };
+    
+    println!(); // Spacing
+
+    // 3. Download Template
+    let pb = ProgressBar::new_spinner();
+    pb.set_style(ProgressStyle::default_spinner().template("{spinner:.cyan} {msg}").unwrap());
+    pb.set_message("Downloading template...");
+    pb.enable_steady_tick(std::time::Duration::from_millis(80));
+    
+    let zip_path = download_template().await?;
+    pb.finish_with_message(format!("{} Template downloaded", "✓".green()));
+
+    // 4. Extract Template
+    let pb = ProgressBar::new_spinner();
+    pb.set_style(ProgressStyle::default_spinner().template("{spinner:.cyan} {msg}").unwrap());
+    pb.set_message("Extracting project structure...");
+    pb.enable_steady_tick(std::time::Duration::from_millis(80));
+    
+    extract_template(&zip_path, &target_dir, lang_folder)?;
+    std::fs::remove_file(&zip_path).ok(); // Cleanup zip
+    pb.finish_with_message(format!("{} Project extracted", "✓".green()));
+
+    // 5. Customize Configuration
+    let pb = ProgressBar::new_spinner();
+    pb.set_style(ProgressStyle::default_spinner().template("{spinner:.cyan} {msg}").unwrap());
+    pb.set_message("Configuring project...");
+    pb.enable_steady_tick(std::time::Duration::from_millis(80));
+    
+    customize_package_json(&target_dir, &name, &opts)?;
+    customize_env(&target_dir, &opts)?;
+    customize_config(&target_dir, &name, &opts)?;
+    customize_readme(&target_dir, &name, &opts)?;
+    
+    // Process .config file for dependencies
+    if let Err(e) = process_dot_config(&target_dir) {
+        // Log warning but don't fail hard, proceed with empty deps if config fails
+        pb.println(format!("   {} Warning: Failed to process .config file: {}", "⚠".yellow(), e));
+    }
+
+    pb.finish_with_message(format!("{} Configuration applied", "✓".green()));
+
+    // 5.5 Ensure Runtimes (Bun)
+    let home = std::env::var("HOME").unwrap_or_else(|_| "/tmp".to_string());
+    let xpm_global_bun = std::path::Path::new(&home).join(".xpm_global").join("bin").join("bun");
+    
+    if which::which("bun").is_err() && !xpm_global_bun.exists() {
+        let pb = ProgressBar::new_spinner();
+        pb.set_style(ProgressStyle::default_spinner().template("{spinner:.magenta} {msg}").unwrap());
+        pb.set_message("Bun runtime not found. Preparing neural environment...");
+        pb.enable_steady_tick(std::time::Duration::from_millis(80));
+        
+        if let Err(e) = crate::commands::install::run(vec!["bun".to_string()], false, 3, true, false, false, false, false, false, false).await {
+             pb.println(format!("   {} Warning: Auto-installation of bun failed: {}", "⚠".yellow(), e));
+        }
+        pb.finish_with_message(format!("{} Bun runtime ready", "✓".green()));
+    }
+    println!();
+    println!("{}", "📦 Installing dependencies...".magenta());
+    
+    // Change dir to project dir for installation
+    std::env::set_current_dir(&target_dir)?;
+    
+    // We use our own install command
+    crate::commands::install::run(vec![], false, 3, false, false, false, false, false, false, false).await?;
+
+    // Success Message (Professional & Clean)
+    println!();
+    let elapsed = start_time.elapsed();
+    println!("   {} Project {} initialized successfully in {:.2}s!", "✨".green(), name.bold(), elapsed.as_secs_f64());
+    println!();
+    println!("   {}", "Next steps:".bold());
+    println!("    $ cd {}", name.cyan());
+    println!("    $ xyp dev");
+    println!("    $ cd {} && xyp dev", name.cyan());
+    println!();
+
+    Ok(())
+}
+
+async fn download_template() -> Result<PathBuf> {
+    let client = reqwest::Client::builder()
+        .timeout(std::time::Duration::from_secs(600))
+        .build()?;
+    let resp = client.get(TEMPLATE_URL).send().await
+        .context("Failed to connect to template server")?;
+        
+    if !resp.status().is_success() {
+        return Err(anyhow!("Failed to download template: HTTP {}", resp.status()));
+    }
+    
+    let temp_dir = std::env::temp_dir();
+    let temp_path = temp_dir.join(format!("xypriss-template-{}.zip", uuid::Uuid::new_v4()));
+    
+    let content = resp.bytes().await?;
+    std::fs::write(&temp_path, content)?;
+    
+    Ok(temp_path)
+}
+
+fn extract_template(zip_path: &Path, target_dir: &Path, lang_folder: &str) -> Result<()> {
+    let file = File::open(zip_path)?;
+    let mut archive = zip::ZipArchive::new(file)?;
+
+    std::fs::create_dir_all(target_dir)?;
+
+    for i in 0..archive.len() {
+        let mut file = archive.by_index(i)?;
+        let name = file.name().to_string(); // Clone name to own string locally to avoid borrow issues
+
+        // Check if file is inside the selected language folder (e.g. "TS/")
+        if name.starts_with(lang_folder) {
+            // Strip prefix to root it in target dir
+            // "TS/src/index.ts" -> "src/index.ts"
+            let relative_name = name.strip_prefix(lang_folder)
+                .unwrap_or(&name)
+                .trim_start_matches('/');
+                
+            if relative_name.is_empty() { continue; } // It IS the folder itself
+
+            let out_path = target_dir.join(relative_name);
+
+            if file.is_dir() {
+                std::fs::create_dir_all(&out_path)?;
+            } else {
+                if let Some(parent) = out_path.parent() {
+                    std::fs::create_dir_all(parent)?;
+                }
+                let mut outfile = File::create(&out_path)?;
+                std::io::copy(&mut file, &mut outfile)?;
+            }
+        }
+    }
+    Ok(())
+}
+
+
+fn customize_package_json(root: &Path, name: &str, opts: &InitOptions) -> Result<()> {
+    let path = root.join("package.json");
+    if !path.exists() { return Ok(()); }
+    
+    let content = std::fs::read_to_string(&path)?;
+    let mut json: Value = serde_json::from_str(&content)?;
+    
+    if let Some(obj) = json.as_object_mut() {
+        obj.insert("name".to_string(), Value::String(name.to_lowercase()));
+        let desc = opts.desc.clone().unwrap_or_else(|| format!("XyPriss project: {}", name));
+        obj.insert("description".to_string(), Value::String(desc));
+        if let Some(author) = &opts.author {
+            obj.insert("author".to_string(), Value::String(author.clone()));
+        }
+    }
+    
+    let new_content = serde_json::to_string_pretty(&json)?;
+    std::fs::write(path, new_content)?;
+    Ok(())
+}
+
+fn customize_env(root: &Path, opts: &InitOptions) -> Result<()> {
+    let path = root.join(".env");
+    if !path.exists() { return Ok(()); }
+    
+    let content = std::fs::read_to_string(&path)?;
+    let port = opts.port.unwrap_or(8080);
+    
+    let new_content = content
+        .replace("{{PORT}}", &port.to_string())
+        .replace("PORT=8080", &format!("PORT={}", port));
+
+    std::fs::write(path, new_content)?;
+    Ok(())
+}
+
+fn customize_config(root: &Path, name: &str, opts: &InitOptions) -> Result<()> {
+    let path = root.join("xypriss.config.json");
+    
+    let mut config: Value = if path.exists() {
+        let content = std::fs::read_to_string(&path)?;
+        serde_json::from_str(&content).unwrap_or_else(|_| Value::Object(serde_json::Map::new()))
+    } else {
+        Value::Object(serde_json::Map::new())
+    };
+    
+    let desc = opts.desc.clone().unwrap_or_else(|| format!("XyPriss project: {}", name));
+    let author = opts.author.clone().unwrap_or_else(|| "User".to_string());
+    let alias = opts.alias.clone().unwrap_or_else(|| name.to_string());
+    let port = opts.port.unwrap_or(8080);
+    
+    let sys_config = serde_json::json!({
+        "__version__": "1.0.0",
+        "__author__": author,
+        "__name__": name,
+        "__description__": desc,
+        "__alias__": alias,
+        "__port__": port,
+        "__PORT__": port
+    });
+    
+    if let Some(obj) = config.as_object_mut() {
+        obj.insert("__sys__".to_string(), sys_config);
+    }
+    
+    let new_content = serde_json::to_string_pretty(&config)?;
+    std::fs::write(path, new_content)?;
+    Ok(())
+}
+
+fn customize_readme(root: &Path, name: &str, opts: &InitOptions) -> Result<()> {
+    let path = root.join("README.md");
+    if !path.exists() { return Ok(()); }
+    
+    let desc = opts.desc.clone().unwrap_or_else(|| format!("XyPriss project: {}", name));
+    let port = opts.port.unwrap_or(8080);
+
+    let content = std::fs::read_to_string(&path)?;
+    let new_content = content
+        .replace("{{PROJECT_NAME}}", name)
+        .replace("{{PROJECT_DESCRIPTION}}", &desc)
+        .replace("{{PORT}}", &port.to_string())
+        .replace("{{FEATURES}}", ""); // Clean up placeholder
+        
+    std::fs::write(path, new_content)?;
+    Ok(())
+}
+
+fn process_dot_config(root: &Path) -> Result<()> {
+    let config_path = root.join(".config");
+    if !config_path.exists() {
+        // println!("Warning: .config not found at {}", config_path.display());
+        return Ok(()); 
+    }
+    
+    let content = std::fs::read_to_string(&config_path)?;
+    let lines: Vec<&str> = content.lines().collect();
+    
+    let mut deps: Vec<String> = Vec::new();
+    let mut dev_deps: Vec<String> = Vec::new();
+    let mut in_deps = false;
+    let mut in_dev_deps = false;
+    
+    for line in lines {
+        let raw_trimmed = line.trim();
+        if raw_trimmed.is_empty() || raw_trimmed.starts_with("#") { continue; }
+        
+        // Handle list syntax "- package"
+        let trimmed = raw_trimmed.strip_prefix("-").unwrap_or(raw_trimmed).trim();
+        if trimmed.is_empty() { continue; }
+        
+        let lower = raw_trimmed.to_lowercase(); // check section headers on raw line or trimmed? 
+        // Headers actullement dans le fichier que j'ai vu en zip semblaient etre "Deps:" sans tiret,
+        // mais si "line" commence par "- ", alors "Deps:" ne sera pas matché si je check sur "trimmed" qui a perdu le tiret ?
+        // Non, headers sont probablement "Deps:" tout court.
+        // Mais "Dependencies:" pourrait etre matché.
+        if lower.starts_with("deps:") || lower.starts_with("dependencies:") {
+            in_deps = true;
+            in_dev_deps = false;
+            continue;
+        } else if lower.starts_with("devdeps:") || lower.starts_with("devdependencies:") {
+            in_deps = false;
+            in_dev_deps = true;
+            continue;
+        }
+        
+        if in_deps {
+            deps.push(trimmed.to_string());
+        } else if in_dev_deps {
+            dev_deps.push(trimmed.to_string());
+        }
+    }
+    
+    // println!("Found {} deps and {} devDeps in .config", deps.len(), dev_deps.len());
+    
+    // Now update package.json
+    let pkg_path = root.join("package.json");
+    let pkg_content = std::fs::read_to_string(&pkg_path)?;
+    let mut json: Value = serde_json::from_str(&pkg_content)?;
+    
+    if let Some(obj) = json.as_object_mut() {
+        // Init dependencies object if missing
+        if !obj.contains_key("dependencies") {
+            obj.insert("dependencies".to_string(), serde_json::json!({}));
+        }
+        if !obj.contains_key("devDependencies") {
+            obj.insert("devDependencies".to_string(), serde_json::json!({}));
+        }
+
+        // Populate dependencies ("latest" is clearer than "*")
+        if let Some(d) = obj.get_mut("dependencies").and_then(|v| v.as_object_mut()) {
+            for dep in &deps {
+                d.insert(dep.clone(), Value::String("latest".to_string()));
+            }
+        }
+        
+        // Populate devDependencies ("latest")
+        if let Some(d) = obj.get_mut("devDependencies").and_then(|v| v.as_object_mut()) {
+            for dep in &dev_deps {
+                d.insert(dep.clone(), Value::String("latest".to_string()));
+            }
+        }
+    }
+    
+    let new_content = serde_json::to_string_pretty(&json)?;
+    std::fs::write(pkg_path, new_content)?;
+    
+    // cleanup .config
+    std::fs::remove_file(config_path)?;
+    
+    Ok(())
+}