Phase 3 CLI implementation

Author: vikrezdev

cmd/doctor.go

@@ -0,0 +1,83 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"strings"
+
+	"github.com/Vikrez22/phpvm/internal/paths"
+	"github.com/Vikrez22/phpvm/internal/resolver"
+	"github.com/spf13/cobra"
+)
+
+var doctorCmd = &cobra.Command{
+	Use:   "doctor",
+	Short: "Diagnose common phpvm issues",
+	RunE: func(cmd *cobra.Command, args []string) error {
+		warnings := 0
+		errors := 0
+		fmt.Println("phpvm doctor")
+		fmt.Println()
+
+		if err := os.MkdirAll(paths.Root(), 0755); err != nil {
+			fmt.Printf("x phpvm data directory writable: %v\n", err)
+			errors++
+		} else if err := writeProbe(paths.Root()); err != nil {
+			fmt.Printf("x phpvm data directory writable: %v\n", err)
+			errors++
+		} else {
+			fmt.Println("ok phpvm data directory exists and is writable")
+		}
+
+		if phpPath, err := exec.LookPath("php"); err == nil && !strings.HasPrefix(filepath.ToSlash(phpPath), filepath.ToSlash(paths.RuntimesDir())) {
+			fmt.Printf("warn system PHP appears before phpvm injection: %s\n", phpPath)
+			warnings++
+		} else {
+			fmt.Println("ok no unmanaged PHP conflict detected")
+		}
+
+		versions, err := resolver.InstalledVersions("php")
+		if err != nil {
+			fmt.Printf("x installed PHP versions readable: %v\n", err)
+			errors++
+		} else if len(versions) == 0 {
+			fmt.Println("warn no PHP versions installed")
+			fmt.Println("Fix: phpvm install php@8.3")
+			warnings++
+		} else {
+			fmt.Printf("ok %d PHP version(s) installed\n", len(versions))
+		}
+
+		if os.Getenv("APPDATA") == "" {
+			fmt.Println("warn APPDATA is not set; phpvm will use ~/.phpvm")
+			warnings++
+		} else {
+			fmt.Println("ok APPDATA is set")
+		}
+
+		fmt.Println()
+		if errors > 0 {
+			return fmt.Errorf("doctor found %d error(s)", errors)
+		}
+		if warnings > 0 {
+			fmt.Printf("doctor found %d warning(s)\n", warnings)
+			return nil
+		}
+		fmt.Println("All checks passed. phpvm is healthy.")
+		return nil
+	},
+}
+
+func writeProbe(dir string) error {
+	path := filepath.Join(dir, ".write_test")
+	if err := os.WriteFile(path, []byte("test"), 0644); err != nil {
+		return err
+	}
+	return os.Remove(path)
+}
+
+func init() {
+	rootCmd.AddCommand(doctorCmd)
+}

cmd/helpers.go

@@ -1,8 +1,6 @@
 package cmd
 
 import (
-	"crypto/md5"
-	"fmt"
 	"os"
 	"path/filepath"
 
@@ -11,6 +9,7 @@ import (
 	"github.com/Vikrez22/phpvm/internal/manifest"
 	"github.com/Vikrez22/phpvm/internal/paths"
 	"github.com/Vikrez22/phpvm/internal/resolver"
+	"github.com/Vikrez22/phpvm/internal/state"
 )
 
 func prepareRuntime() (*manifest.Manifest, injector.Runtime, error) {
@@ -36,19 +35,10 @@ func prepareRuntime() (*manifest.Manifest, injector.Runtime, error) {
 		PHPBinDir:  rt.PHPBinDir,
 		PHPIniPath: rt.PHPIniPath,
 		PHPVersion: rt.PHPVersion,
-		ProjectID:  projectHash(m.ProjectRoot),
+		ProjectID:  state.HashProject(m.ProjectRoot),
 	}, nil
 }
 
-func projectHash(projectRoot string) string {
-	abs, err := filepath.Abs(projectRoot)
-	if err != nil {
-		abs = projectRoot
-	}
-	h := md5.Sum([]byte(filepath.ToSlash(abs)))
-	return fmt.Sprintf("%x", h[:6])
-}
-
 func projectDisplayName(m *manifest.Manifest) string {
 	if m.Project != nil && m.Project.Name != "" {
 		return m.Project.Name
@@ -59,3 +49,12 @@ func projectDisplayName(m *manifest.Manifest) string {
 func ensureProjectStateDir(projectRoot string) error {
 	return os.MkdirAll(paths.ProjectStateDir(projectRoot), 0755)
 }
+
+func markActive(projectRoot, phpVersion string) error {
+	ps, err := state.Load(projectRoot)
+	if err != nil {
+		return err
+	}
+	ps.MarkActivePHP(phpVersion)
+	return ps.Save()
+}

cmd/init.go

@@ -1,42 +1,155 @@
 package cmd
 
 import (
+	"bufio"
 	"fmt"
 	"os"
+	"path/filepath"
+	"strings"
 
 	"github.com/spf13/cobra"
 )
 
 var initCmd = &cobra.Command{
 	Use:   "init",
 	Short: "Create a runtime.yml in the current directory",
-	RunE: func(cmd *cobra.Command, args []string) error {
-		if _, err := os.Stat("runtime.yml"); err == nil {
-			return fmt.Errorf("runtime.yml already exists")
+	RunE:  runInit,
+}
+
+func init() {
+	initCmd.Flags().String("php", "", "PHP version (default: 8.3)")
+	initCmd.Flags().String("mysql", "", "MySQL version (optional)")
+	initCmd.Flags().Bool("nginx", true, "Use Nginx as web server")
+	initCmd.Flags().Bool("apache", false, "Use Apache as web server")
+	initCmd.Flags().BoolP("yes", "y", false, "Skip interactive prompts")
+	rootCmd.AddCommand(initCmd)
+}
+
+func runInit(cmd *cobra.Command, args []string) error {
+	cwd, err := os.Getwd()
+	if err != nil {
+		return err
+	}
+	manifestPath := filepath.Join(cwd, "runtime.yml")
+	if _, err := os.Stat(manifestPath); err == nil {
+		yes, _ := cmd.Flags().GetBool("yes")
+		if !yes && !confirm("runtime.yml already exists. Overwrite? [y/N] ", false) {
+			fmt.Println("Cancelled.")
+			return nil
 		}
+	}
 
-		content := `phpvm: "1"
+	if detected := detectProjectType(cwd); detected != "" {
+		fmt.Printf("Detected: %s\n\n", detected)
+	}
 
-runtime:
-  php: "8.3"
+	phpVersion := promptOrFlag(cmd, "php", "PHP version", "8.3")
+	mysqlVersion := promptOrFlag(cmd, "mysql", "MySQL version (leave blank to skip)", "")
+	serverEngine := "nginx"
+	if apache, _ := cmd.Flags().GetBool("apache"); apache {
+		serverEngine = "apache"
+	}
 
-database:
-  engine: none
+	content := buildManifestContent(phpVersion, mysqlVersion, serverEngine, cwd)
+	if err := os.WriteFile(manifestPath, []byte(content), 0644); err != nil {
+		return fmt.Errorf("cannot write runtime.yml: %w", err)
+	}
+
+	fmt.Println("Created runtime.yml")
+	fmt.Println("Next: run 'phpvm install' then 'phpvm up'")
+	return nil
+}
 
-server:
-  engine: nginx
-  root: public
-`
-		if err := os.WriteFile("runtime.yml", []byte(content), 0644); err != nil {
-			return fmt.Errorf("cannot write runtime.yml: %w", err)
+func buildManifestContent(php, mysql, server, projectDir string) string {
+	name := filepath.Base(projectDir)
+	domain := strings.ToLower(strings.ReplaceAll(name, "_", "-")) + ".local"
+	lines := []string{
+		"# runtime.yml - managed by phpvm",
+		`phpvm: "1"`,
+		"",
+		"runtime:",
+		fmt.Sprintf(`  php: "%s"`, php),
+	}
+	if mysql != "" {
+		lines = append(lines,
+			"",
+			"database:",
+			"  engine: mysql",
+			fmt.Sprintf(`  version: "%s"`, mysql),
+		)
+	} else {
+		lines = append(lines, "", "database:", "  engine: none")
+	}
+	lines = append(lines,
+		"",
+		"server:",
+		fmt.Sprintf("  engine: %s", server),
+		"  root: public",
+		"",
+		"project:",
+		fmt.Sprintf("  name: %s", name),
+		fmt.Sprintf("  domain: %s", domain),
+	)
+	return strings.Join(lines, "\n") + "\n"
+}
+
+func detectProjectType(dir string) string {
+	data, err := os.ReadFile(filepath.Join(dir, "composer.json"))
+	if err != nil {
+		if _, statErr := os.Stat(filepath.Join(dir, "index.php")); statErr == nil {
+			return "PHP project"
+		}
+		return ""
+	}
+	content := string(data)
+	switch {
+	case strings.Contains(content, "laravel/framework"):
+		if strings.Contains(content, `"^11`) {
+			return "Laravel 11 project"
+		}
+		if strings.Contains(content, `"^10`) {
+			return "Laravel 10 project"
 		}
+		return "Laravel project"
+	case strings.Contains(content, "symfony/symfony"):
+		return "Symfony project"
+	case strings.Contains(strings.ToLower(content), "wordpress"):
+		return "WordPress project"
+	default:
+		return "PHP project (composer.json found)"
+	}
+}
 
-		fmt.Println("Created runtime.yml")
-		fmt.Println("Next: run 'phpvm install' then 'phpvm up'")
-		return nil
-	},
+func promptOrFlag(cmd *cobra.Command, flag, label, defaultVal string) string {
+	if cmd.Flags().Changed(flag) {
+		val, _ := cmd.Flags().GetString(flag)
+		return val
+	}
+	yes, _ := cmd.Flags().GetBool("yes")
+	if yes {
+		return defaultVal
+	}
+	if defaultVal == "" {
+		fmt.Printf("%s: ", label)
+	} else {
+		fmt.Printf("%s [%s]: ", label, defaultVal)
+	}
+	reader := bufio.NewReader(os.Stdin)
+	answer, _ := reader.ReadString('\n')
+	answer = strings.TrimSpace(answer)
+	if answer == "" {
+		return defaultVal
+	}
+	return answer
 }
 
-func init() {
-	rootCmd.AddCommand(initCmd)
+func confirm(prompt string, defaultYes bool) bool {
+	fmt.Print(prompt)
+	reader := bufio.NewReader(os.Stdin)
+	answer, _ := reader.ReadString('\n')
+	answer = strings.ToLower(strings.TrimSpace(answer))
+	if answer == "" {
+		return defaultYes
+	}
+	return strings.HasPrefix(answer, "y")
 }

cmd/restore.go

@@ -0,0 +1,45 @@
+package cmd
+
+import (
+	"fmt"
+	"os"
+	"path/filepath"
+
+	"github.com/Vikrez22/phpvm/internal/manifest"
+	"github.com/Vikrez22/phpvm/internal/paths"
+	"github.com/spf13/cobra"
+)
+
+var restoreCmd = &cobra.Command{
+	Use:   "restore <name>",
+	Short: "Restore environment from a snapshot",
+	Args:  cobra.ExactArgs(1),
+	RunE: func(cmd *cobra.Command, args []string) error {
+		cwd, err := os.Getwd()
+		if err != nil {
+			return err
+		}
+		m, err := manifest.Find(cwd)
+		if err != nil {
+			return err
+		}
+		name := args[0]
+		snapshotPath := filepath.Join(paths.ProjectStateDir(m.ProjectRoot), "snapshots", name+".yml")
+		if _, err := os.Stat(snapshotPath); err != nil {
+			return fmt.Errorf("snapshot not found: %s", name)
+		}
+		snap, err := manifest.ParseFile(snapshotPath)
+		if err != nil {
+			return err
+		}
+		if err := updateManifestPHPVersion(m.FilePath, snap.Runtime.PHP); err != nil {
+			return err
+		}
+		fmt.Printf("Restored snapshot %s: PHP %s\n", name, snap.Runtime.PHP)
+		return nil
+	},
+}
+
+func init() {
+	rootCmd.AddCommand(restoreCmd)
+}

cmd/run.go

@@ -11,10 +11,13 @@ var runCmd = &cobra.Command{
 	Args:               cobra.MinimumNArgs(1),
 	DisableFlagParsing: true,
 	RunE: func(cmd *cobra.Command, args []string) error {
-		_, rt, err := prepareRuntime()
+		m, rt, err := prepareRuntime()
 		if err != nil {
 			return err
 		}
+		if err := markActive(m.ProjectRoot, rt.PHPVersion); err != nil {
+			return err
+		}
 		return injector.RunCommand(rt, args)
 	},
 }

cmd/shell.go

@@ -17,6 +17,9 @@ var shellCmd = &cobra.Command{
 		if err != nil {
 			return err
 		}
+		if err := markActive(m.ProjectRoot, rt.PHPVersion); err != nil {
+			return err
+		}
 		fmt.Printf("Activating PHP %s for %s...\n", rt.PHPVersion, projectDisplayName(m))
 		return injector.SpawnShell(rt, shellName)
 	},