all_java_code_report.txt

package com.projectwizard;

/**
 * Classe de entrada alternativa para evitar problemas com o Java Module System (JPMS).
 * Ao iniciar a aplicação por uma classe que não estende 'Application', o JavaFX
 * permite que dependências não-modulares funcionem corretamente no Classpath.
 */
public class Launcher {
    public static void main(String[] args) {
        Main.main(args);
    }
}
package com.projectwizard;

import com.projectwizard.view.MainWindow;
//import javafx.application.Application;
import javafx.scene.Scene;
import javafx.stage.Stage;
import com.projectwizard.theme.ThemeManager;
import com.projectwizard.theme.ThemeType;
import com.projectwizard.view.sidebar.Sidebar;
import com.projectwizard.view.dashboard.DashboardView;
import com.projectwizard.service.PersistenceService;
import com.projectwizard.core.navigation.NavigationController;
import com.projectwizard.core.navigation.NavigationTarget;
import java.io.File;


public class App {

    public void start(Stage stage) {

    	ThemeManager.apply(ThemeType.PRIMER_DARK);
        MainWindow window = new MainWindow();
        window.show(stage);

        // Restaurar último projeto aberto (Estilo Navegador)
        restoreLastProject();

        Scene scene = stage.getScene();

        if (scene != null) {

            scene.getStylesheets().add(
                    getClass()
                            .getResource("/themes/projectwizard.css")
                            .toExternalForm()
            );

        }

    }

    private void restoreLastProject() {
        PersistenceService persistence = new PersistenceService();
        String lastPath = persistence.getLastProjectPath();
        if (lastPath != null) {
            File projectDir = new File(lastPath);
            if (projectDir.exists() && projectDir.isDirectory()) {
                NavigationController.getInstance()
                        .navigateWithProject(NavigationTarget.WORKSPACE, projectDir);
            }
        }
    }

}
package com.projectwizard.view.openproject;

import java.io.File;

import javafx.geometry.Insets;
import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.stage.DirectoryChooser;
import javafx.stage.Window;

import com.projectwizard.view.explorer.PackageExplorer;
import com.projectwizard.view.explorer.FileTreeCell;
import com.projectwizard.view.editor.EditorHost;
import com.projectwizard.view.editor.EditorSupport;
import com.projectwizard.service.git.GitService;
import com.projectwizard.core.navigation.NavigationController;
import com.projectwizard.core.navigation.NavigationTarget;

public class OpenProjectView extends BorderPane {

    private final TextField pathField = new TextField();
    private final Button browseButton = new Button("Browse...");
    private final Button openButton = new Button("Open");
    private final Button cancelButton = new Button("Cancel");
    private File selectedDirectory;
    private final PackageExplorer explorer = new PackageExplorer();
    private final TextArea info = new TextArea();
    private final EditorHost editorHost = new EditorHost();
    private GitService gitService;

    public OpenProjectView() {
        setPadding(new Insets(20));

        Label title = new Label("Open Project");
        title.setStyle("-fx-font-size:26px;-fx-font-weight:bold;");

        pathField.setPromptText("Choose a project folder...");
        pathField.setEditable(false);

        HBox pathBox = new HBox(10, pathField, browseButton);
        HBox.setHgrow(pathField, Priority.ALWAYS);

        info.setEditable(false);
        info.setText("Choose a folder to continue.");
        info.setWrapText(true);
        VBox.setVgrow(info, Priority.ALWAYS);

        openButton.setDisable(true);
        browseButton.setOnAction(e -> handleBrowse());
        openButton.setOnAction(e -> handleOpen());
        cancelButton.setOnAction(e -> handleCancel());

        HBox buttons = new HBox(10, openButton, cancelButton);
        VBox center = new VBox(20, title, pathBox, info, buttons);

        TabPane tabPane = new TabPane();
        tabPane.setTabClosingPolicy(TabPane.TabClosingPolicy.UNAVAILABLE);
        tabPane.getTabs().addAll(
            new Tab("📁 Explorer", explorer),
            new Tab("📝 Editor", editorHost)
        );

        SplitPane split = new SplitPane();
        split.getItems().addAll(tabPane, center);
        split.setDividerPositions(0.40);

        setCenter(split);
        setupDoubleClickHandler();
    }

    private void handleBrowse() {
        Window window = getScene().getWindow();
        DirectoryChooser chooser = new DirectoryChooser();
        chooser.setTitle("Open Project Folder");

        File dir = chooser.showDialog(window);
        if (dir != null) {
            selectedDirectory = dir;
            gitService = new GitService(dir);

            explorer.setCellFactory(v -> new FileTreeCell());
            explorer.openProject(dir);
            pathField.setText(dir.getAbsolutePath());

            info.setText("Folder selected:\n\n" + dir.getAbsolutePath()
                    + "\n\n" + gitService.getRepositoryInfo()
                    + "\n\n💡 Double-click files to preview in tabs. Click Open to load workspace!");

            openButton.setDisable(false);
        }
    }

    private void handleOpen() {
        if (selectedDirectory == null) {
            showAlert("Error", "No folder selected!", Alert.AlertType.ERROR);
            return;
        }

        try {
            NavigationController.getInstance()
                    .navigateWithProject(NavigationTarget.WORKSPACE, selectedDirectory);
        } catch (Exception e) {
            showAlert("Error", "Failed: " + e.getMessage(), Alert.AlertType.ERROR);
        }
    }

    private void handleCancel() {
        pathField.clear();
        selectedDirectory = null;
        openButton.setDisable(true);
        info.setText("Choose a folder to continue.");
        explorer.setRoot(null);
        editorHost.clear();
    }

    private void setupDoubleClickHandler() {
        explorer.setOnMouseClicked(event -> {
            if (event.getClickCount() == 2) {
                TreeItem<File> selected = explorer.getSelectionModel().getSelectedItem();
                if (selected != null && selected.getValue() != null && selected.getValue().isFile()) {
                    File file = selected.getValue();
                    if (EditorSupport.isTextFile(file)) {
                        editorHost.openFile(file);
                        info.setText("📄 " + file.getName()
                                + "\n📍 " + file.getAbsolutePath()
                                + "\n📑 Tabs open: " + editorHost.getOpenTabCount());
                    }
                }
            }
        });
    }

    private void showAlert(String title, String message, Alert.AlertType type) {
        Alert alert = new Alert(type);
        alert.setTitle(title);
        alert.setHeaderText(null);
        alert.setContentText(message);
        alert.showAndWait();
    }

}
package com.projectwizard.view.explorer;

import java.io.File;
import java.util.Arrays;

import javafx.scene.control.TreeItem;
import javafx.scene.control.TreeView;

/**
 * Enhanced PackageExplorer with Lazy Loading and Smart Filtering
 * 
 * Features:
 * - Lazy loads folders on expand
 * - Auto-filters build artifacts
 * - Alphabetically sorted
 * - Supports large projects
 */
public class PackageExplorer extends TreeView<File> {

    private static final String[] FILTERED_NAMES = {
        ".git", ".gitignore", ".github", ".gitlab-ci.yml",
        "target", "node_modules", ".idea", "build", ".gradle",
        ".vscode", ".DS_Store", "*.class", "dist", "out", "bin",
        ".settings", ".classpath", ".project", ".mvn", "pom.xml.bak"
    };

    public PackageExplorer() {
        setShowRoot(true);
    }

    public void openProject(File rootFolder) {
        if (rootFolder == null)
            return;

        TreeItem<File> root = create(rootFolder);
        setRoot(root);
        root.setExpanded(true);
    }

    private TreeItem<File> create(File file) {
        TreeItem<File> item = new TreeItem<>(file);

        if (file.isDirectory()) {
            File[] files = listFilteredFiles(file);

            if (files != null && files.length > 0) {
                TreeItem<File> placeholder = new TreeItem<File>(null) {
                    @Override
                    public String toString() {
                        return "Loading...";
                    }
                };
                item.getChildren().add(placeholder);

                item.expandedProperty().addListener((obs, oldVal, newVal) -> {
                    if (newVal && item.getChildren().size() == 1) {
                        TreeItem<File> ph = item.getChildren().get(0);
                        if (ph.getValue() == null) {
                            item.getChildren().clear();
                            loadChildren(item);
                        }
                    }
                });
            }
        }

        return item;
    }

    private void loadChildren(TreeItem<File> parent) {
        File[] files = listFilteredFiles(parent.getValue());

        if (files != null) {
            for (File child : files) {
                parent.getChildren().add(create(child));
            }
        }
    }

    private File[] listFilteredFiles(File directory) {
        if (directory == null)
            return null;

        File[] files = directory.listFiles();
        if (files == null)
            return null;

        File[] filtered = Arrays.stream(files)
            .filter(f -> !shouldFilter(f.getName()))
            .sorted()
            .toArray(File[]::new);

        return filtered.length > 0 ? filtered : null;
    }

    private boolean shouldFilter(String name) {
        for (String filter : FILTERED_NAMES) {
            if (filter.startsWith("*")) {
                String ext = filter.substring(1);
                if (name.endsWith(ext))
                    return true;
            } else if (name.equals(filter) || name.startsWith(filter)) {
                return true;
            }
        }
        return false;
    }

}
package com.projectwizard.view.explorer;

import java.io.File;
import javafx.geometry.Insets;
import javafx.scene.control.TreeCell;
import javafx.scene.layout.HBox;
import javafx.scene.text.Text;
import org.kordamp.ikonli.javafx.FontIcon;
import org.kordamp.ikonli.material2.Material2AL;
import org.kordamp.ikonli.material2.Material2MZ;
import org.kordamp.ikonli.fontawesome5.FontAwesomeSolid;
import org.kordamp.ikonli.fontawesome5.FontAwesomeBrands;

/**
 * FileTreeCell with Professional Icons and Syntax Highlighting Colors
 */
public class FileTreeCell extends TreeCell<File> {

    @Override
    protected void updateItem(File item, boolean empty) {
        super.updateItem(item, empty);

        if (empty || item == null) {
            setText(null);
            setGraphic(null);
        } else {
            String displayName = item.getName().isBlank()
                    ? item.getAbsolutePath()
                    : item.getName();

            FontIcon icon = getFileIcon(item);
            String styleClass = getFileStyleClass(item);
            
            icon.getStyleClass().add(styleClass);
            icon.setIconSize(16);
            
            Text nameText = new Text(displayName);
            nameText.getStyleClass().add(styleClass);

            HBox hbox = new HBox(8, icon, nameText);
            hbox.setPadding(new Insets(2));

            setGraphic(hbox);
            setText(null);
        }
    }

    private String getFileStyleClass(File file) {
        if (file.isDirectory()) return "file-folder";
        
        String name = file.getName().toLowerCase();
        if (name.endsWith(".java")) return "file-java";
        if (name.endsWith(".xml") || name.endsWith(".fxml")) return "file-xml";
        if (name.endsWith(".md")) return "file-md";
        if (name.endsWith(".sh") || name.endsWith(".bat")) return "file-sh";
        if (name.endsWith(".js") || name.endsWith(".ts")) return "file-js";
        if (name.endsWith(".css") || name.endsWith(".scss")) return "file-css";
        if (name.endsWith(".json")) return "file-json";
        
        return "file-default";
    }

    private FontIcon getFileIcon(File file) {
        if (file.isDirectory()) {
            String name = file.getName().toLowerCase();
            if (name.equals("src")) return new FontIcon(Material2MZ.SOURCE);
            if (name.equals("test")) return new FontIcon(Material2MZ.SCIENCE);
            if (name.equals("resources")) return new FontIcon(Material2MZ.STORAGE);
            if (name.equals("target") || name.equals("build")) return new FontIcon(Material2AL.BUILD);
            if (name.equals(".git")) return new FontIcon(Material2AL.ACCOUNT_TREE);
            return new FontIcon(Material2AL.FOLDER);
        }

        String name = file.getName().toLowerCase();
        if (name.endsWith(".java")) return new FontIcon(FontAwesomeSolid.COFFEE);
        if (name.endsWith(".xml") || name.endsWith(".fxml")) return new FontIcon(Material2AL.CODE);
        if (name.endsWith(".md")) return new FontIcon(Material2AL.DESCRIPTION);
        if (name.endsWith(".sh") || name.endsWith(".bat")) return new FontIcon(FontAwesomeSolid.TERMINAL);
        if (name.endsWith(".js") || name.endsWith(".ts")) return new FontIcon(FontAwesomeBrands.JS);
        if (name.endsWith(".css") || name.endsWith(".scss")) return new FontIcon(Material2MZ.PALETTE);
        if (name.endsWith(".json")) return new FontIcon(Material2MZ.SETTINGS_ETHERNET);
        if (name.startsWith(".")) return new FontIcon(Material2AL.LOCK);

        return new FontIcon(Material2AL.INSERT_DRIVE_FILE);
    }
}
package com.projectwizard.view.git;

import javafx.geometry.Pos;
import javafx.scene.control.Label;
import javafx.scene.layout.BorderPane;

public class GitView extends BorderPane {

    public GitView() {

        Label label = new Label("Git");

        label.setStyle(
            "-fx-font-size:28px;" +
            "-fx-font-weight:bold;"
        );

        setCenter(label);

        BorderPane.setAlignment(label, Pos.CENTER);

    }

}
package com.projectwizard.view;

import com.projectwizard.core.navigation.NavigationController;

import com.projectwizard.view.dashboard.DashboardView;
import javafx.scene.Node;
import javafx.scene.layout.BorderPane;

public class WorkspacePane extends BorderPane {

    private static WorkspacePane instance;

    public WorkspacePane() {

        instance = this;

        NavigationController.getInstance().setWorkspace(this);

        showDashboard();

    }

    public static WorkspacePane getInstance() {

        return instance;

    }

    public void setContent(Node node) {

        setCenter(node);

    }

    public void showDashboard() {

        setContent(new DashboardView());

    }

}
package com.projectwizard.view.editor;

import javafx.scene.control.*;
import javafx.scene.layout.*;
import javafx.stage.FileChooser;
import java.io.File;
import java.nio.file.Files;
import java.util.ArrayList;
import java.util.List;
import java.util.stream.Collectors;

import com.projectwizard.core.ApplicationContext;
import com.projectwizard.service.PersistenceService;

public class EditorHost extends BorderPane {
    private final TabPane tabPane = new TabPane();
    private final PersistenceService persistence = new PersistenceService();

    public EditorHost() {
        tabPane.setTabClosingPolicy(TabPane.TabClosingPolicy.ALL_TABS);
        setupToolBar();
        setCenter(tabPane);

        // Salvar estado quando abas mudam
        tabPane.getTabs().addListener((javafx.collections.ListChangeListener.Change<? extends Tab> c) -> {
            saveState();
        });
    }

    private void saveState() {
        List<String> paths = tabPane.getTabs().stream()
                .filter(t -> t.getContent() instanceof EditorPane)
                .map(t -> ((EditorPane) t.getContent()).getFile().getAbsolutePath())
                .collect(Collectors.toList());
        persistence.saveOpenFiles(paths);
    }

    public void restoreState() {
        List<String> paths = persistence.getOpenFiles();
        for (String path : paths) {
            File file = new File(path);
            if (file.exists() && file.isFile()) {
                openFile(file);
            }
        }
    }

    private void setupToolBar() {
        Button btnSave = new Button("💾 Save");
        Button btnSaveAs = new Button("📂 Save As...");
        btnSave.setOnAction(e -> handleSave());
        btnSaveAs.setOnAction(e -> handleSaveAs());
        setTop(new ToolBar(btnSave, btnSaveAs));
    }

    private void handleSave() {
        Tab selected = tabPane.getSelectionModel().getSelectedItem();
        if (selected != null && selected.getContent() instanceof EditorPane pane) {
            try {
                ApplicationContext.getInstance().getFileSystemService().saveFile(pane.getFile(), pane.getText());
            } catch (Exception ex) {
                ApplicationContext.getInstance().getDialogService().showError("Error", ex.getMessage());
            }
        }
    }

    private void handleSaveAs() {
        Tab selected = tabPane.getSelectionModel().getSelectedItem();
        if (selected != null && selected.getContent() instanceof EditorPane pane) {
            FileChooser chooser = new FileChooser();
            File file = chooser.showSaveDialog(getScene().getWindow());
            if (file != null) {
                try {
                    ApplicationContext.getInstance().getFileSystemService().saveFile(file, pane.getText());
                    selected.setText(file.getName());
                } catch (Exception ex) {
                    ApplicationContext.getInstance().getDialogService().showError("Error", ex.getMessage());
                }
            }
        }
    }

    // Sobrecarga para aceitar apenas o File (Lê o conteúdo automaticamente)
    public void openFile(File file) {
        try {
            String content = Files.readString(file.toPath());
            openFile(file, content);
        } catch (Exception e) {
            ApplicationContext.getInstance().getDialogService().showError("Read Error", e.getMessage());
        }
    }

    public void openFile(File file, String content) {
        // Verifica se o arquivo já está aberto para evitar duplicidade
        for (Tab tab : tabPane.getTabs()) {
            if (tab.getText().equals(file.getName())) {
                tabPane.getSelectionModel().select(tab);
                return;
            }
        }
        Tab tab = new Tab(file.getName());
        tab.setContent(new EditorPane(file, content));
        tabPane.getTabs().add(tab);
        tabPane.getSelectionModel().select(tab);
    }

    public void clear() {
        tabPane.getTabs().clear();
    }

    public int getOpenTabCount() {
        return tabPane.getTabs().size();
    }
}
package com.projectwizard.view.editor;

import java.io.File;
import java.nio.charset.StandardCharsets;
import java.nio.file.Files;

public final class EditorSupport {

    private static final String[] TEXT_EXTENSIONS = {
        ".java", ".xml", ".json", ".properties", ".yml", ".yaml",
        ".md", ".txt", ".html", ".fxml", ".css", ".scss", ".sql", ".sh",
        ".gradle", ".kt", ".groovy", ".toml", ".ini", ".cfg", ".log",
        ".js", ".jsx", ".ts", ".tsx", ".py", ".pyw", ".bat", ".cmd"
    };

    private static final int MAX_PREVIEW_CHARS = 50_000;

    private EditorSupport() {
    }

    public static boolean isTextFile(File file) {
        if (file == null) {
            return false;
        }
        String name = file.getName().toLowerCase();
        for (String ext : TEXT_EXTENSIONS) {
            if (name.endsWith(ext)) {
                return true;
            }
        }
        return false;
    }

    public static String readFileContent(File file) throws Exception {
        if (!isTextFile(file)) {
            return "[Binary file: " + file.getName() + "]";
        }
        String content = Files.readString(file.toPath(), StandardCharsets.UTF_8);
        if (content.length() > MAX_PREVIEW_CHARS) {
            int remaining = content.length() - MAX_PREVIEW_CHARS;
            content = content.substring(0, MAX_PREVIEW_CHARS)
                    + "\n\n... [Truncated: " + remaining + " chars] ...";
        }
        return content;
    }

    public static String formatSize(long bytes) {
        if (bytes <= 0) {
            return "0 B";
        }
        final String[] units = {"B", "KB", "MB", "GB"};
        int digitGroups = (int) (Math.log10(bytes) / Math.log10(1024));
        digitGroups = Math.min(digitGroups, units.length - 1);
        return String.format("%.1f %s", bytes / Math.pow(1024, digitGroups), units[digitGroups]);
    }

}
package com.projectwizard.view.editor;

import java.io.File;
import java.util.Collection;
import java.util.Collections;

import javafx.concurrent.Task;
import javafx.scene.layout.BorderPane;

import org.fxmisc.flowless.VirtualizedScrollPane;
import org.fxmisc.richtext.CodeArea;
import org.fxmisc.richtext.LineNumberFactory;
import org.fxmisc.richtext.model.StyleSpans;
import org.fxmisc.richtext.model.StyleSpansBuilder;

import com.projectwizard.service.editor.JetBrainsSyntaxScanner;

/**
 * EditorPane com Realce de Sintaxe Industrial.
 */
public class EditorPane extends BorderPane {

    private static final long MAX_FILE_SIZE = 1024 * 1024; // 1MB

    private final CodeArea codeArea = new CodeArea();
    private final JetBrainsSyntaxScanner scanner = new JetBrainsSyntaxScanner();
    private File currentFile;

    public EditorPane(File file, String content) {
        this.currentFile = file;

        codeArea.setParagraphGraphicFactory(LineNumberFactory.get(codeArea));
        codeArea.replaceText(content);

        if (file != null && file.length() > MAX_FILE_SIZE) {
            System.err.println("[JDT] Arquivo muito grande para realce.");
            setCenter(new VirtualizedScrollPane<>(codeArea));
            return;
        }

        // Listener assíncrono para manter a UI fluida
        codeArea.multiPlainChanges().subscribe(ignore -> runHighlightingAsync());

        // Realce da linha atual
        codeArea.setParagraphStyle(0, Collections.singleton("current-line"));
        codeArea.caretPositionProperty().addListener((obs, oldPos, newPos) -> {
            int oldLine = codeArea.offsetToPosition(oldPos, CodeArea.Bias.Forward).getMajor();
            int newLine = codeArea.offsetToPosition(newPos, CodeArea.Bias.Forward).getMajor();
            if (oldLine != newLine) {
                codeArea.setParagraphStyle(oldLine, Collections.emptyList());
                codeArea.setParagraphStyle(newLine, Collections.singleton("current-line"));
            }
        });

        runHighlightingAsync();
        setCenter(new VirtualizedScrollPane<>(codeArea));
    }

    private void runHighlightingAsync() {
        String text = codeArea.getText();

        Task<StyleSpans<Collection<String>>> highlightTask = new Task<>() {
            @Override
            protected StyleSpans<Collection<String>> call() {
                return computeHighlighting(text);
            }
        };

        highlightTask.setOnSucceeded(
                e -> codeArea.setStyleSpans(0, highlightTask.getValue()));

        Thread thread = new Thread(highlightTask);
        thread.setDaemon(true);
        thread.start();
    }

    private StyleSpans<Collection<String>> computeHighlighting(String text) {
        StyleSpansBuilder<Collection<String>> spansBuilder =
                new StyleSpansBuilder<>();

        final int[] lastKwEnd = { 0 };

        String processableText = text.length() > 50000
                ? text.substring(0, 50000)
                : text;

        String fileName = currentFile != null ? currentFile.getName() : "Main.java";

        scanner.tokenize(processableText, fileName, (type, start, end) -> {

            int spacer = start - lastKwEnd[0];
            if (spacer > 0) {
                spansBuilder.add(Collections.singleton("token-default"), spacer);
            }

            spansBuilder.add(Collections.singleton(type), end - start);

            lastKwEnd[0] = end;
        });

        int remaining = text.length() - lastKwEnd[0];
        if (remaining > 0) {
            spansBuilder.add(Collections.singleton("token-default"), remaining);
        }

        return spansBuilder.create();
    }

    public String getText() {
        return codeArea.getText();
    }

    public File getFile() {
        return currentFile;
    }
}package com.projectwizard.view.about;

import javafx.geometry.Pos;
import javafx.scene.control.Label;
import javafx.scene.layout.BorderPane;

public class AboutView extends BorderPane {

    public AboutView() {

        Label label = new Label("About Project Wizard");

        label.setStyle(
            "-fx-font-size:28px;" +
            "-fx-font-weight:bold;"
        );

        setCenter(label);

        BorderPane.setAlignment(label, Pos.CENTER);

    }

}
package com.projectwizard.view.settings;

import javafx.geometry.Pos;
import javafx.scene.control.Label;
import javafx.scene.layout.BorderPane;

public class SettingsView extends BorderPane {

    public SettingsView() {

        Label label = new Label("Settings");

        label.setStyle(
            "-fx-font-size:28px;" +
            "-fx-font-weight:bold;"
        );

        setCenter(label);

        BorderPane.setAlignment(label, Pos.CENTER);

    }

}
package com.projectwizard.view.templates;

import javafx.geometry.Pos;
import javafx.scene.control.Label;
import javafx.scene.layout.BorderPane;

public class TemplatesView extends BorderPane {

    public TemplatesView() {

        Label label = new Label("Templates");

        label.setStyle(
            "-fx-font-size:28px;" +
            "-fx-font-weight:bold;"
        );

        setCenter(label);

        BorderPane.setAlignment(label, Pos.CENTER);

    }

}
package com.projectwizard.view.newproject;

import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.control.Button;
import javafx.scene.control.ComboBox;
import javafx.scene.control.Label;
import javafx.scene.control.Separator;
import javafx.scene.control.TextField;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.GridPane;
import javafx.scene.layout.HBox;
import javafx.scene.layout.VBox;

public class NewProjectView extends BorderPane {

    public NewProjectView() {

        setPadding(new Insets(20));

        VBox left = new VBox(15);

        left.getChildren().addAll(
                createStep("① Project"),
                createStep("② Language"),
                createStep("③ Framework"),
                createStep("④ Dependencies"),
                createStep("⑤ Git"),
                createStep("⑥ Summary")
        );

        left.setPrefWidth(220);

        GridPane form = new GridPane();

        form.setHgap(10);
        form.setVgap(12);

        Label title = new Label("Create New Project");

        title.setStyle(
                "-fx-font-size:26px;" +
                "-fx-font-weight:bold;"
        );

        TextField projectName = new TextField();

        TextField group = new TextField("com.example");

        TextField artifact = new TextField();

        ComboBox<String> language = new ComboBox<>();

        language.getItems().addAll(
                "Java",
                "Kotlin",
                "Groovy"
        );

        language.getSelectionModel().selectFirst();

        ComboBox<String> build = new ComboBox<>();

        build.getItems().addAll(
                "Maven",
                "Gradle"
        );

        build.getSelectionModel().selectFirst();

        form.add(title,0,0,2,1);

        form.add(new Label("Project Name"),0,1);
        form.add(projectName,1,1);

        form.add(new Label("Group"),0,2);
        form.add(group,1,2);

        form.add(new Label("Artifact"),0,3);
        form.add(artifact,1,3);

        form.add(new Label("Language"),0,4);
        form.add(language,1,4);

        form.add(new Label("Build Tool"),0,5);
        form.add(build,1,5);

        HBox buttons = new HBox(10);

        Button back = new Button("◀ Back");

        Button next = new Button("Next ▶");

        Button finish = new Button("Finish");

        buttons.getChildren().addAll(
                back,
                next,
                finish
        );

        buttons.setAlignment(Pos.CENTER_RIGHT);

        VBox center = new VBox(20);

        center.getChildren().addAll(

                form,

                new Separator(),

                buttons

        );

        setLeft(left);

        setCenter(center);

    }

    private Label createStep(String text){

        Label label = new Label(text);

        label.setMaxWidth(Double.MAX_VALUE);

        label.setStyle(
                "-fx-font-size:15px;" +
                "-fx-padding:8;"
        );

        return label;

    }

}
package com.projectwizard.view;

import com.projectwizard.core.ApplicationContext;
import javafx.scene.Scene;
import javafx.scene.control.Menu;
import javafx.scene.control.MenuBar;
import javafx.scene.control.MenuItem;
import javafx.scene.layout.BorderPane;
import javafx.scene.layout.VBox;
import javafx.stage.Stage;

public class MainWindow {

    private final ApplicationContext context =
            ApplicationContext.getInstance();

    public void show(Stage stage) {

        BorderPane root = new BorderPane();

        MenuBar menuBar = new MenuBar();

        Menu file = new Menu("File");
        Menu help = new Menu("Help");

        MenuItem exit = new MenuItem("Exit");
        exit.setOnAction(e -> stage.close());

        MenuItem about = new MenuItem("About");

        about.setOnAction(e ->
                context.getDialogService().showInformation(
                        "About",
                        context.getApplicationName()
                                + "\nVersion "
                                + context.getVersion()
                )
        );

        file.getItems().add(exit);
        help.getItems().add(about);

        menuBar.getMenus().addAll(file, help);

        VBox top = new VBox(
                menuBar,
                new MainToolBar()
        );

        root.setTop(top);


        WorkspacePane workspace = new WorkspacePane();

        root.setCenter(workspace);

        root.setBottom(
                new StatusBar()
        );

        Scene scene =
                new Scene(root, 1400, 850);

        stage.setScene(scene);
        stage.setTitle(
                context.getApplicationName()
        );

        stage.centerOnScreen();
        stage.show();

    }

}
package com.projectwizard.view.dashboard;

import javafx.geometry.Pos;
import javafx.scene.control.Button;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;

public class DashboardView extends VBox {

    public DashboardView() {

        setSpacing(20);

        setAlignment(Pos.CENTER);

        Label title = new Label("Project Wizard");

        title.setStyle("-fx-font-size:30px;-fx-font-weight:bold;");

        Label subtitle = new Label(
                "Create amazing projects"
        );

        Button newProject = new Button("New Project");

        Button openProject = new Button("Open Project");

        getChildren().addAll(

                title,

                subtitle,

                newProject,

                openProject

        );

    }

}
package com.projectwizard.view;

import com.projectwizard.core.ApplicationContext;
import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.control.Label;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;

public class StatusBar extends HBox {

    public StatusBar() {

        ApplicationContext context = ApplicationContext.getInstance();

        Label status = new Label("Ready");

        Label version = new Label(context.getVersion());

        HBox spacer = new HBox();

        HBox.setHgrow(spacer, Priority.ALWAYS);

        getChildren().addAll(
                status,
                spacer,
                version
        );

        setPadding(new Insets(6,10,6,10));
        setAlignment(Pos.CENTER_LEFT);

    }

}
package com.projectwizard.view.github;

import javafx.geometry.Pos;
import javafx.scene.control.Label;
import javafx.scene.layout.BorderPane;

public class GitHubView extends BorderPane {

    public GitHubView() {

        Label label = new Label("GitHub");

        label.setStyle(
            "-fx-font-size:28px;" +
            "-fx-font-weight:bold;"
        );

        setCenter(label);

        BorderPane.setAlignment(label, Pos.CENTER);

    }

}
package com.projectwizard.view.projecttype;

import javafx.geometry.Insets;
import javafx.scene.control.*;
import javafx.scene.layout.*;

public class ProjectTypeView extends BorderPane {

    public ProjectTypeView() {

        setPadding(new Insets(15));

        ///////////////////////////////////////////////////////
        // TOPO
        ///////////////////////////////////////////////////////

        Label title = new Label("Choose Project Type");

        title.setStyle(
                "-fx-font-size:28px;" +
                "-fx-font-weight:bold;"
        );

        TextField search = new TextField();
        search.setPromptText("Search templates...");

        ComboBox<String> category = new ComboBox<>();

        category.getItems().addAll(
                "All",
                "Java",
                "Desktop",
                "Spring",
                "Library",
                "CLI"
        );

        category.getSelectionModel().selectFirst();

        HBox toolbar = new HBox(10);

        HBox.setHgrow(search, Priority.ALWAYS);

        toolbar.getChildren().addAll(
                search,
                category
        );

        VBox top = new VBox(15);

        top.getChildren().addAll(
                title,
                toolbar
        );

        setTop(top);

        ///////////////////////////////////////////////////////
        // ESQUERDA (CATÁLOGO)
        ///////////////////////////////////////////////////////

        FlowPane cards = new FlowPane();

        cards.setHgap(15);
        cards.setVgap(15);

        cards.getChildren().addAll(

                new ProjectCard(
                        "☕",
                        "Java Console",
                        "Classic Java application."
                ),

                new ProjectCard(
                        "🖥",
                        "JavaFX Desktop",
                        "Desktop application with AtlantaFX."
                ),

                new ProjectCard(
                        "🌱",
                        "Spring Boot",
                        "REST API template."
                ),

                new ProjectCard(
                        "📦",
                        "Maven",
                        "Standard Maven project."
                ),

                new ProjectCard(
                        "🐘",
                        "Gradle",
                        "Standard Gradle project."
                ),

                new ProjectCard(
                        "📚",
                        "Java Library",
                        "Reusable library."
                )

        );

        ScrollPane scroll = new ScrollPane(cards);

        scroll.setFitToWidth(true);

        ///////////////////////////////////////////////////////
        // DIREITA (DETAILS)
        ///////////////////////////////////////////////////////

        VBox details = new VBox(12);

        details.setPadding(new Insets(15));

        details.setPrefWidth(320);

        Label detailsTitle = new Label("Template Details");

        detailsTitle.setStyle(
                "-fx-font-size:22px;" +
                "-fx-font-weight:bold;"
        );

        Label projectName = new Label("JavaFX Desktop");

        projectName.setStyle(
                "-fx-font-size:18px;" +
                "-fx-font-weight:bold;"
        );

        Label description = new Label(
                "Desktop application using JavaFX\n" +
                "with AtlantaFX Theme."
        );

        description.setWrapText(true);

        Separator sep = new Separator();

        Label tech = new Label(
                "Java 17\n" +
                "JavaFX\n" +
                "AtlantaFX\n" +
                "Maven"
        );

        Button create = new Button("Create Project");

        create.setMaxWidth(Double.MAX_VALUE);

        details.getChildren().addAll(

                detailsTitle,

                projectName,

                description,

                sep,

                tech,

                new Separator(),

                create

        );

        ///////////////////////////////////////////////////////

        SplitPane split = new SplitPane();

        split.getItems().addAll(

                scroll,

                details

        );

        split.setDividerPositions(0.70);

        setCenter(split);

    }

}
package com.projectwizard.view.projecttype;

import javafx.geometry.Insets;
import javafx.scene.control.Label;
import javafx.scene.layout.VBox;

public class ProjectCard extends VBox {

    public ProjectCard(
            String icon,
            String title,
            String description
    ) {

        setSpacing(6);
        setPadding(new Insets(15));

        setPrefWidth(260);

        setStyle(
            "-fx-background-radius:10;" +
            "-fx-border-radius:10;" +
            "-fx-border-color:#555;" +
            "-fx-padding:15;"
        );

        Label iconLabel = new Label(icon);
        iconLabel.setStyle("-fx-font-size:28px;");

        Label titleLabel = new Label(title);
        titleLabel.setStyle(
                "-fx-font-size:18px;" +
                "-fx-font-weight:bold;"
        );

        Label descriptionLabel =
                new Label(description);

        descriptionLabel.setWrapText(true);

        getChildren().addAll(
                iconLabel,
                titleLabel,
                descriptionLabel
        );

    }

}
package com.projectwizard.view.sidebar;

import com.projectwizard.core.navigation.NavigationController;
import com.projectwizard.core.navigation.NavigationTarget;

import javafx.geometry.Insets;
import javafx.scene.control.Button;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;

public class Sidebar extends VBox {

    public Sidebar() {

        setSpacing(6);
        setPadding(new Insets(10));
        setPrefWidth(220);

        create("🏠 Home", NavigationTarget.HOME);
        create("📦 New Project", NavigationTarget.NEW_PROJECT);
        create("📂 Open Project", NavigationTarget.OPEN_PROJECT);
        create("📚 Templates", NavigationTarget.TEMPLATES);
        create("🌱 Git", NavigationTarget.GIT);
        create("🐙 GitHub", NavigationTarget.GITHUB);
        create("⚙ Settings", NavigationTarget.SETTINGS);
        create("ℹ About", NavigationTarget.ABOUT);

    }

    private void create(String text, NavigationTarget target) {

        Button b = new Button(text);

        b.setMaxWidth(Double.MAX_VALUE);

        VBox.setVgrow(b, Priority.NEVER);

        b.setOnAction(e -> {

            System.out.println("[NAV] " + target);

            NavigationController
                    .getInstance()
                    .navigate(target);

        });

        getChildren().add(b);

    }

}
package com.projectwizard.view;

import javafx.scene.control.Button;
import javafx.scene.control.ToolBar;

import com.projectwizard.core.navigation.NavigationController;
import com.projectwizard.core.navigation.NavigationTarget;

public class MainToolBar extends ToolBar {

    public MainToolBar() {

        Button newProject = new Button("New Project");

        Button open = new Button("Open");

        open.setOnAction(e ->
                NavigationController.getInstance()
                        .navigate(NavigationTarget.OPEN_PROJECT)
        );

        Button settings = new Button("Settings");

        getItems().addAll(
                newProject,
                open,
                settings
        );
    }
}
package com.projectwizard.view;

import com.projectwizard.core.navigation.NavigationController;
import com.projectwizard.core.navigation.NavigationTarget;
import javafx.geometry.Insets;
import javafx.scene.control.Button;
import javafx.scene.control.Separator;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;

public class NavigationPane extends VBox {

    public NavigationPane() {

        setSpacing(8);
        setPadding(new Insets(10));
        setPrefWidth(230);

        addButton("🏠 Home", NavigationTarget.HOME);
        addButton("📦 New Project", NavigationTarget.NEW_PROJECT);
        addButton("📂 Open Project", NavigationTarget.OPEN_PROJECT);
        addButton("📁 Templates", NavigationTarget.TEMPLATES);

        getChildren().add(new Separator());

        addButton("🌿 Git", NavigationTarget.GIT);
        addButton("☁ GitHub", NavigationTarget.GITHUB);

        getChildren().add(new Separator());

        addButton("⚙ Settings", NavigationTarget.SETTINGS);
        addButton("ℹ About", NavigationTarget.ABOUT);

        VBox spacer = new VBox();
        VBox.setVgrow(spacer, Priority.ALWAYS);

        getChildren().add(spacer);

        Button version = new Button("Project Wizard 1.0");
        version.setDisable(true);
        version.setMaxWidth(Double.MAX_VALUE);

        getChildren().add(version);
    }

    private void addButton(String text, NavigationTarget target) {

        Button button = new Button(text);

        button.setPrefHeight(36);
        button.setMaxWidth(Double.MAX_VALUE);

        button.setOnAction(e ->
                NavigationController
                        .getInstance()
                        .navigate(target));

        getChildren().add(button);

    }

}
package com.projectwizard.workspace;

import java.io.File;

import javafx.geometry.Insets;
import javafx.scene.control.SplitPane;
import javafx.scene.control.TreeItem;
import javafx.scene.layout.BorderPane;

import com.projectwizard.model.Project;
import com.projectwizard.view.editor.EditorHost;
import com.projectwizard.view.editor.EditorSupport;
import com.projectwizard.view.explorer.PackageExplorer;
import com.projectwizard.view.explorer.FileTreeCell;

public class ProjectWorkspace extends BorderPane {

    private Project currentProject;
    private PackageExplorer explorer;
    private EditorHost editor;
    private ProjectHeader header;

    public ProjectWorkspace() {
        setPadding(new Insets(0));
    }

    public void loadProject(File projectRoot) {
        currentProject = new Project(projectRoot);
        header = new ProjectHeader(currentProject);
        setTop(header);

        explorer = new PackageExplorer();
        explorer.setCellFactory(v -> new FileTreeCell());
        explorer.openProject(projectRoot);

        editor = new EditorHost();
        setupFileOpenHandler();

        // Restaurar arquivos abertos anteriormente no editor
        editor.restoreState();

        SplitPane splitPane = new SplitPane();
        splitPane.getItems().addAll(explorer, editor);
        splitPane.setDividerPositions(0.25);

        setCenter(splitPane);
    }

    private void setupFileOpenHandler() {
        explorer.setOnMouseClicked(event -> {
            if (event.getClickCount() == 2) {
                TreeItem<File> selected = explorer.getSelectionModel().getSelectedItem();
                if (selected != null && selected.getValue() != null) {
                    File file = selected.getValue();
                    if (file.isFile() && EditorSupport.isTextFile(file)) {
                        editor.openFile(file);
                    }
                }
            }
        });
    }

    public Project getCurrentProject() {
        return currentProject;
    }

}
package com.projectwizard.workspace;

import javafx.geometry.Insets;
import javafx.geometry.Pos;
import javafx.scene.control.Label;
import javafx.scene.layout.HBox;
import javafx.scene.layout.Priority;
import javafx.scene.layout.VBox;
import javafx.scene.text.Font;
import javafx.scene.text.FontWeight;

import com.projectwizard.model.Project;
import com.projectwizard.service.git.GitService;

public class ProjectHeader extends VBox {

    private Project project;
    private GitService gitService;

    public ProjectHeader(Project project) {
        this.project = project;
        this.gitService = new GitService(project.getRootDirectory());

        setStyle("-fx-background-color: #f5f5f5; -fx-border-color: #ddd; "
                + "-fx-border-width: 0 0 1 0;");
        setPadding(new Insets(15, 20, 15, 20));
        setSpacing(8);

        getChildren().addAll(createTitleRow(), createInfoRow());
    }

    private HBox createTitleRow() {
        HBox hbox = new HBox(15);
        hbox.setAlignment(Pos.CENTER_LEFT);

        Label titleLabel = new Label("📁 " + project.getName());
        titleLabel.setFont(Font.font("System", FontWeight.BOLD, 18));

        if (gitService.isGitRepository()) {
            Label gitBadge = new Label("🌿 Git");
            gitBadge.setStyle("-fx-background-color: #e8f5e9; "
                    + "-fx-text-fill: #2e7d32; -fx-padding: 3 8; "
                    + "-fx-border-radius: 3; -fx-background-radius: 3;");
            hbox.getChildren().addAll(titleLabel, gitBadge);
        } else {
            hbox.getChildren().add(titleLabel);
        }

        HBox spacer = new HBox();
        HBox.setHgrow(spacer, Priority.ALWAYS);
        hbox.getChildren().add(spacer);

        return hbox;
    }

    private HBox createInfoRow() {
        HBox hbox = new HBox(20);
        hbox.setAlignment(Pos.CENTER_LEFT);

        Label pathLabel = new Label("📍 " + project.getRootDirectory().getAbsolutePath());
        pathLabel.setStyle("-fx-text-fill: #666;");
        hbox.getChildren().add(pathLabel);

        if (gitService.isGitRepository()) {
            String branchInfo = "🔀 Branch: " + gitService.getCurrentBranch();
            Label branchLabel = new Label(branchInfo);
            branchLabel.setStyle("-fx-text-fill: #1976d2;");
            hbox.getChildren().add(branchLabel);

            if (!gitService.getRemoteUrl().isEmpty()) {
                Label remoteLabel = new Label("🔗 " + gitService.getRemoteUrl());
                remoteLabel.setStyle("-fx-text-fill: #666; -fx-font-size: 11;");
                hbox.getChildren().add(remoteLabel);
            }
        }

        return hbox;
    }

}
package com.projectwizard.service.git;

import java.io.File;
import java.nio.file.Files;
import java.nio.file.Paths;

/**
 * GitService - Detects and manages Git repository information
 * 
 * Features:
 * - Detects if folder is a Git repository
 * - Reads .git/config for remote info
 * - Shows branch information
 * - Displays recent commits
 */
public class GitService {

    private final File projectRoot;
    private boolean isGitRepository = false;
    private String remoteUrl = "";
    private String currentBranch = "unknown";

    public GitService(File projectRoot) {
        this.projectRoot = projectRoot;
        detectGitRepository();
    }

    /**
     * Detects if folder is a Git repository
     */
    private void detectGitRepository() {
        if (projectRoot == null)
            return;

        File gitDir = new File(projectRoot, ".git");
        isGitRepository = gitDir.exists() && gitDir.isDirectory();

        if (isGitRepository) {
            readGitConfig();
            readCurrentBranch();
        }
    }

    /**
     * Reads git remote URL from .git/config
     */
    private void readGitConfig() {
        try {
            File configFile = new File(projectRoot, ".git/config");
            if (configFile.exists()) {
                String content = new String(Files.readAllBytes(configFile.toPath()));
                // Simple parsing for remote url
                if (content.contains("url = ")) {
                    String[] lines = content.split("\n");
                    for (String line : lines) {
                        if (line.contains("url = ")) {
                            remoteUrl = line.replace("url = ", "").trim();
                            break;
                        }
                    }
                }
            }
        } catch (Exception e) {
            System.err.println("Error reading git config: " + e.getMessage());
        }
    }

    /**
     * Reads current branch name
     */
    private void readCurrentBranch() {
        try {
            File headFile = new File(projectRoot, ".git/HEAD");
            if (headFile.exists()) {
                String content = new String(Files.readAllBytes(headFile.toPath())).trim();
                if (content.startsWith("ref: refs/heads/")) {
                    currentBranch = content.replace("ref: refs/heads/", "");
                }
            }
        } catch (Exception e) {
            System.err.println("Error reading current branch: " + e.getMessage());
        }
    }

    // Getters
    public boolean isGitRepository() {
        return isGitRepository;
    }

    public String getRemoteUrl() {
        return remoteUrl;
    }

    public String getCurrentBranch() {
        return currentBranch;
    }

    public String getRepositoryInfo() {
        if (!isGitRepository)
            return "Not a Git repository";

        StringBuilder info = new StringBuilder();
        info.append("📌 Git Repository\n");
        info.append("Branch: ").append(currentBranch).append("\n");
        if (!remoteUrl.isEmpty()) {
            info.append("Remote: ").append(remoteUrl);
        }
        return info.toString();
    }

}
package com.projectwizard.service;

public class SettingsService {

    public String getTheme() {

        return "Default";

    }

}
package com.projectwizard.service;

public class ProjectService {

    public void createProject() {

        System.out.println("Project creation will be implemented in a future step.");

    }

}
package com.projectwizard.service;

import java.io.File;
import java.nio.file.Files;
import java.nio.charset.StandardCharsets;

public class FileSystemService {
    public void saveFile(File file, String content) throws Exception {
        if (file == null) return;
        Files.writeString(file.toPath(), content, StandardCharsets.UTF_8);
    }
}
package com.projectwizard.service.editor;

import com.intellij.lang.java.lexer.JavaLexer;
import com.intellij.lexer.Lexer;
import com.intellij.lexer.XmlLexer;
import com.intellij.pom.java.LanguageLevel;
import com.intellij.psi.tree.IElementType;
import java.util.Set;
import java.util.HashSet;
import java.util.Arrays;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/**
 * JetBrainsSyntaxScanner - Realce de sintaxe profissional e resiliente.
 * Suporta Java, XML/FXML, Markdown (.md), Shell Script (.sh), JS/TS e CSS.
 */
public class JetBrainsSyntaxScanner {

    private static final Set<String> JAVA_KEYWORDS = new HashSet<>(Arrays.asList(
        "abstract", "assert", "boolean", "break", "byte", "case", "catch", "char", "class", "const",
        "continue", "default", "do", "double", "else", "enum", "extends", "final", "finally", "float",
        "for", "goto", "if", "implements", "import", "instanceof", "int", "interface", "long", "native",
        "new", "package", "private", "protected", "public", "return", "short", "static", "strictfp",
        "super", "switch", "synchronized", "this", "throw", "throws", "transient", "try", "void",
        "volatile", "while", "true", "false", "null", "var", "record", "yield", "sealed", "non-sealed", "permits"
    ));

    private static final Set<String> SH_KEYWORDS = new HashSet<>(Arrays.asList(
        "if", "then", "else", "elif", "fi", "for", "in", "do", "done", "while", "until", "case", "esac", "function", "select", "time"
    ));

    private static final Set<String> JS_KEYWORDS = new HashSet<>(Arrays.asList(
        "async", "await", "break", "case", "catch", "class", "const", "continue", "debugger", "default", "delete", "do",
        "else", "enum", "export", "extends", "false", "finally", "for", "function", "if", "import", "in", "instanceof",
        "new", "null", "return", "super", "switch", "this", "throw", "true", "try", "typeof", "var", "void", "while",
        "with", "yield", "let", "static", "of", "get", "set"
    ));

    // Regex para Markdown
    private static final Pattern MD_PATTERN = Pattern.compile(
            "(?<HEADER>^(#+)(.*)$)" +
            "|(?<CODEBLOCK>```[\\s\\S]*?```|`[^`\\n]+`)" +
            "|(?<BOLD>\\*\\*.*?\\*\\*|__.*?__)" +
            "|(?<ITALIC>\\*.*?\\*|_.*?_)" +
            "|(?<LINK>\\[.*?\\]\\(.*?\\))" +
            "|(?<LIST>^[ \\t]*[*+-][ \\t]+.*$)" +
            "|(?<QUOTE>^[ \\t]*>.*$)",
            Pattern.MULTILINE
    );

    // Regex para Shell Script
    private static final Pattern SH_PATTERN = Pattern.compile(
            "(?<COMMENT>#.*)" +
            "|(?<STRING>\"(\\\\.|[^\"])*\"|'[^']*')" +
            "|(?<VARIABLE>\\$([a-zA-Z_][a-zA-Z0-9_]*|\\{[^}]+\\}|[0-9]))" +
            "|(?<KEYWORD>\\b(" + String.join("|", SH_KEYWORDS) + ")\\b)" +
            "|(?<COMMANDSUB>\\$\\([^)]+\\)|`[^`]+`)"
    );

    // Regex para JavaScript / TypeScript
    private static final Pattern JS_PATTERN = Pattern.compile(
            "(?<COMMENT>//.*|/\\*[\\s\\S]*?\\*/)" +
            "|(?<STRING>\"(\\\\.|[^\"])*\"|'(\\\\.|[^'])*'|`(\\\\.|[^`])*`)" +
            "|(?<KEYWORD>\\b(" + String.join("|", JS_KEYWORDS) + ")\\b)" +
            "|(?<NUMBER>\\b\\d+(\\.\\d+)?\\b)" +
            "|(?<ANNOTATION>@[a-zA-Z_][a-zA-Z0-9_]*)"
    );

    // Regex para CSS
    private static final Pattern CSS_PATTERN = Pattern.compile(
            "(?<COMMENT>/\\*[\\s\\S]*?\\*/)" +
            "|(?<SELECTOR>(^|\\})[^{]+(?=\\{))" +
            "|(?<PROPERTY>[a-zA-Z\\- ]+(?=:))" +
            "|(?<VALUE>:[^;\\}]+)" +
            "|(?<BRACE>[\\{\\}])"
    );

    public void tokenize(String source, String fileName, TokenHandler handler) {
        if (source == null || source.isEmpty()) return;

        if (fileName != null) {
            String lowerName = fileName.toLowerCase();
            if (lowerName.endsWith(".md")) {
                tokenizeByPattern(source, MD_PATTERN, handler, "md");
                return;
            }
            if (lowerName.endsWith(".sh") || lowerName.endsWith(".bash")) {
                tokenizeByPattern(source, SH_PATTERN, handler, "sh");
                return;
            }
            if (lowerName.endsWith(".js") || lowerName.endsWith(".ts") || lowerName.endsWith(".jsx") || lowerName.endsWith(".tsx")) {
                tokenizeByPattern(source, JS_PATTERN, handler, "js");
                return;
            }
            if (lowerName.endsWith(".css") || lowerName.endsWith(".scss")) {
                tokenizeByPattern(source, CSS_PATTERN, handler, "css");
                return;
            }
        }

        Lexer lexer = getLexerForFile(fileName);
        lexer.start(source);

        while (lexer.getTokenType() != null) {
            IElementType type = lexer.getTokenType();
            int start = lexer.getTokenStart();
            int end = lexer.getTokenEnd();

            String styleClass = mapTypeToStyle(type, fileName);
            handler.onToken(styleClass, start, end);

            lexer.advance();
        }
    }

    private void tokenizeByPattern(String source, Pattern pattern, TokenHandler handler, String lang) {
        Matcher matcher = pattern.matcher(source);
        int lastKwEnd = 0;
        while (matcher.find()) {
            String styleClass = "token-default";
            
            if (lang.equals("md")) {
                if (matcher.group("HEADER") != null) styleClass = "token-md-header";
                else if (matcher.group("CODEBLOCK") != null) styleClass = "token-md-code";
                else if (matcher.group("BOLD") != null) styleClass = "token-md-bold";
                else if (matcher.group("ITALIC") != null) styleClass = "token-md-italic";
                else if (matcher.group("LINK") != null) styleClass = "token-md-link";
                else if (matcher.group("LIST") != null) styleClass = "token-md-list";
                else if (matcher.group("QUOTE") != null) styleClass = "token-md-quote";
            } else if (lang.equals("sh")) {
                if (matcher.group("COMMENT") != null) styleClass = "token-comment";
                else if (matcher.group("STRING") != null) styleClass = "token-string";
                else if (matcher.group("VARIABLE") != null) styleClass = "token-sh-var";
                else if (matcher.group("KEYWORD") != null) styleClass = "token-keyword";
                else if (matcher.group("COMMANDSUB") != null) styleClass = "token-sh-cmd";
            } else if (lang.equals("js")) {
                if (matcher.group("COMMENT") != null) styleClass = "token-comment";
                else if (matcher.group("STRING") != null) styleClass = "token-string";
                else if (matcher.group("KEYWORD") != null) styleClass = "token-keyword";
                else if (matcher.group("NUMBER") != null) styleClass = "token-number";
                else if (matcher.group("ANNOTATION") != null) styleClass = "token-annotation";
            } else if (lang.equals("css")) {
                if (matcher.group("COMMENT") != null) styleClass = "token-comment";
                else if (matcher.group("SELECTOR") != null) styleClass = "token-tag"; // Seletor como tag
                else if (matcher.group("PROPERTY") != null) styleClass = "token-attribute"; // Propriedade como atributo
                else if (matcher.group("VALUE") != null) styleClass = "token-string"; // Valor como string
                else if (matcher.group("BRACE") != null) styleClass = "token-punctuation";
            }

            if (matcher.start() > lastKwEnd) {
                handler.onToken("token-default", lastKwEnd, matcher.start());
            }
            handler.onToken(styleClass, matcher.start(), matcher.end());
            lastKwEnd = matcher.end();
        }
        if (source.length() > lastKwEnd) {
            handler.onToken("token-default", lastKwEnd, source.length());
        }
    }

    private Lexer getLexerForFile(String fileName) {
        if (fileName != null && (fileName.endsWith(".xml") || fileName.endsWith(".fxml"))) {
            return new XmlLexer();
        }
        return new JavaLexer(LanguageLevel.JDK_21);
    }

    private String mapTypeToStyle(IElementType type, String fileName) {
        String name = type.toString().toUpperCase();

        if (fileName != null && (fileName.endsWith(".xml") || fileName.endsWith(".fxml"))) {
            if (name.contains("TAG_NAME") || name.contains("XML_NAME")) return "token-tag";
            if (name.contains("ATTRIBUTE_NAME")) return "token-attribute";
            if (name.contains("ATTRIBUTE_VALUE") || name.contains("STRING") || name.contains("XML_CHAR_ENTITY")) return "token-string";
            if (name.contains("COMMENT")) return "token-comment";
            if (name.contains("TAG_CHAR") || name.contains("START_TAG") || name.contains("END_TAG") || 
                name.contains("XML_EQ") || name.contains("XML_PI") || name.contains("DOCTYPE") || name.contains("CONDITIONAL_SECTION")) return "token-punctuation";
            return "token-default";
        }

        String lowerName = type.toString().toLowerCase();
        if (JAVA_KEYWORDS.contains(lowerName) || name.contains("KEYWORD")) return "token-keyword";
        if (name.contains("COMMENT")) return "token-comment";
        if (name.contains("STRING") || name.contains("CHAR_LITERAL")) return "token-string";
        if (name.contains("NUMBER") || (name.contains("LITERAL") && (name.contains("INT") || name.contains("FLOAT") || name.contains("DOUBLE") || name.contains("LONG")))) return "token-number";
        if (name.equals("@") || name.contains("AT")) return "token-annotation";
        
        if (name.contains("EQ") || name.contains("GT") || name.contains("LT") || 
            name.contains("PLUS") || name.contains("MINUS") || name.contains("ASTERISK") || 
            name.contains("DIV") || name.contains("OR") || name.contains("AND") || 
            name.contains("PERC") || name.contains("QUEST") || name.contains("COLON") ||
            name.contains("EXCL") || name.contains("TILDE") || name.contains("AMPER") || name.contains("BAR")) return "token-operator";

        if (name.contains("PAREN") || name.contains("BRACE") || name.contains("BRACKET") || 
            name.contains("SEMICOLON") || name.contains("COMMA") || name.contains("DOT")) return "token-punctuation";

        if (name.contains("IDENTIFIER")) return "token-identifier";

        return "token-default";
    }

    public interface TokenHandler {
        void onToken(String type, int start, int end);
    }
}
package com.projectwizard.service;

import javafx.scene.control.Alert;
import javafx.scene.control.Alert.AlertType;

public class DialogService {
    public void showError(String title, String message) {
        Alert alert = new Alert(AlertType.ERROR);
        alert.setTitle(title);
        alert.setHeaderText(null);
        alert.setContentText(message);
        alert.showAndWait();
    }
    
    public void showInfo(String title, String message) {
        showInformation(title, message);
    }

    public void showInformation(String title, String message) {
        Alert alert = new Alert(AlertType.INFORMATION);
        alert.setTitle(title);
        alert.setHeaderText(null);
        alert.setContentText(message);
        alert.showAndWait();
    }
}
package com.projectwizard.service;

import java.io.*;
import java.util.Properties;

public class PersistenceService {

    private static final String CONFIG_FILE = System.getProperty("user.home") + File.separator + ".projectwizard.properties";
    private static final String LAST_PROJECT_KEY = "last.project.path";
    private static final String OPEN_FILES_KEY = "open.files";

    public void saveLastProjectPath(String path) {
        Properties props = loadProperties();
        props.setProperty(LAST_PROJECT_KEY, path);
        saveProperties(props);
    }

    public void saveOpenFiles(java.util.List<String> filePaths) {
        Properties props = loadProperties();
        props.setProperty(OPEN_FILES_KEY, String.join(",", filePaths));
        saveProperties(props);
    }

    public String getLastProjectPath() {
        return loadProperties().getProperty(LAST_PROJECT_KEY);
    }

    public java.util.List<String> getOpenFiles() {
        String files = loadProperties().getProperty(OPEN_FILES_KEY);
        if (files == null || files.isEmpty()) return java.util.Collections.emptyList();
        return java.util.Arrays.asList(files.split(","));
    }

    private Properties loadProperties() {
        Properties props = new Properties();
        try (InputStream in = new FileInputStream(CONFIG_FILE)) {
            props.load(in);
        } catch (IOException e) {
        }
        return props;
    }

    private void saveProperties(Properties props) {
        try (OutputStream out = new FileOutputStream(CONFIG_FILE)) {
            props.store(out, "ProjectWizard Settings");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}
package com.projectwizard.service;

import com.projectwizard.view.WorkspacePane;
import javafx.scene.Node;

public class NavigationService {

    private WorkspacePane workspace;

    public void setWorkspace(WorkspacePane workspace) {
        this.workspace = workspace;
    }

    public void navigate(Node node) {
        if (workspace != null) {
            workspace.setContent(node);
        }
    }

}
package com.projectwizard.theme;

public enum ThemeType {

    DRACULA,

    NORD_DARK,
    NORD_LIGHT,

    PRIMER_DARK,
    PRIMER_LIGHT,

    CUPERTINO_DARK,
    CUPERTINO_LIGHT

}
package com.projectwizard.theme;

import atlantafx.base.theme.CupertinoDark;
import atlantafx.base.theme.CupertinoLight;
import atlantafx.base.theme.Dracula;
import atlantafx.base.theme.NordDark;
import atlantafx.base.theme.NordLight;
import atlantafx.base.theme.PrimerDark;
import atlantafx.base.theme.PrimerLight;
import javafx.application.Application;

public final class ThemeManager {

    private static ThemeType currentTheme = ThemeType.PRIMER_DARK;

    private ThemeManager() {
    }

    public static ThemeType getCurrentTheme() {

        return currentTheme;

    }

    public static void apply(ThemeType theme) {

        currentTheme = theme;

        switch (theme) {

            case DRACULA ->
                Application.setUserAgentStylesheet(
                        new Dracula().getUserAgentStylesheet());

            case NORD_DARK ->
                Application.setUserAgentStylesheet(
                        new NordDark().getUserAgentStylesheet());

            case NORD_LIGHT ->
                Application.setUserAgentStylesheet(
                        new NordLight().getUserAgentStylesheet());

            case PRIMER_DARK ->
                Application.setUserAgentStylesheet(
                        new PrimerDark().getUserAgentStylesheet());

            case PRIMER_LIGHT ->
                Application.setUserAgentStylesheet(
                        new PrimerLight().getUserAgentStylesheet());

            case CUPERTINO_DARK ->
                Application.setUserAgentStylesheet(
                        new CupertinoDark().getUserAgentStylesheet());

            case CUPERTINO_LIGHT ->
                Application.setUserAgentStylesheet(
                        new CupertinoLight().getUserAgentStylesheet());

        }

    }

}
package com.projectwizard.model;

import java.io.File;
import java.time.LocalDateTime;

public class Project {

    private File rootDirectory;
    private String name;
    private String description;
    private boolean isGitRepository;
    private String gitBranch;
    private String gitRemote;
    private LocalDateTime lastOpened;
    private LocalDateTime created;

    public Project(File rootDirectory) {
        this.rootDirectory = rootDirectory;
        this.name = rootDirectory.getName();
        this.lastOpened = LocalDateTime.now();
        this.created = LocalDateTime.now();
    }

    public File getRootDirectory() {
        return rootDirectory;
    }

    public void setRootDirectory(File rootDirectory) {
        this.rootDirectory = rootDirectory;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    public String getDescription() {
        return description;
    }

    public void setDescription(String description) {
        this.description = description;
    }

    public boolean isGitRepository() {
        return isGitRepository;
    }

    public void setGitRepository(boolean gitRepository) {
        isGitRepository = gitRepository;
    }

    public String getGitBranch() {
        return gitBranch;
    }

    public void setGitBranch(String gitBranch) {
        this.gitBranch = gitBranch;
    }

    public String getGitRemote() {
        return gitRemote;
    }

    public void setGitRemote(String gitRemote) {
        this.gitRemote = gitRemote;
    }

    public LocalDateTime getLastOpened() {
        return lastOpened;
    }

    public void setLastOpened(LocalDateTime lastOpened) {
        this.lastOpened = lastOpened;
    }

    public LocalDateTime getCreated() {
        return created;
    }

    public void setCreated(LocalDateTime created) {
        this.created = created;
    }

    @Override
    public String toString() {
        return "Project{" +
                "name='" + name + '\'' +
                ", path='" + rootDirectory.getAbsolutePath() + '\'' +
                '}';
    }

}
package com.projectwizard.core;

public final class Version {

    private Version() {
    }

    public static final String VERSION = "0.1.0";

}
package com.projectwizard.core;

public final class Constants {

    private Constants() {
    }

    public static final String APPLICATION_NAME = "Project Wizard";

}
package com.projectwizard.core;

import com.projectwizard.service.*;

public class ApplicationContext {
    private static ApplicationContext instance;
    private final ProjectService projectService = new ProjectService();
    private final FileSystemService fileSystemService = new FileSystemService();
    private final DialogService dialogService = new DialogService();

    private ApplicationContext() {}

    public static synchronized ApplicationContext getInstance() {
        if (instance == null) instance = new ApplicationContext();
        return instance;
    }

    public String getApplicationName() { return "Project Wizard"; }
    public String getVersion() { return "1.0.0"; }
    
    public ProjectService getProjectService() { return projectService; }
    public FileSystemService getFileSystemService() { return fileSystemService; }
    public DialogService getDialogService() { return dialogService; }
}
package com.projectwizard.core.navigation;

import java.io.File;

import com.projectwizard.service.PersistenceService;
import com.projectwizard.view.WorkspacePane;
import com.projectwizard.view.about.AboutView;
import com.projectwizard.view.dashboard.DashboardView;
import com.projectwizard.view.git.GitView;
import com.projectwizard.view.github.GitHubView;
import com.projectwizard.view.newproject.NewProjectView;
import com.projectwizard.view.openproject.OpenProjectView;
import com.projectwizard.view.settings.SettingsView;
import com.projectwizard.view.templates.TemplatesView;
import com.projectwizard.workspace.ProjectWorkspace;

public final class NavigationController {

    private static final NavigationController INSTANCE = new NavigationController();
    private WorkspacePane workspace;
    private ProjectWorkspace projectWorkspace;

    private NavigationController() {
    }

    public static NavigationController getInstance() {
        return INSTANCE;
    }

    public void setWorkspace(WorkspacePane workspace) {
        this.workspace = workspace;
    }

    public void navigate(NavigationTarget target) {
        if (workspace == null) return;

        switch (target) {
            case HOME -> workspace.setContent(new DashboardView());
            case NEW_PROJECT -> workspace.setContent(new NewProjectView());
            case OPEN_PROJECT -> workspace.setContent(new OpenProjectView());
            case TEMPLATES -> workspace.setContent(new TemplatesView());
            case GIT -> workspace.setContent(new GitView());
            case GITHUB -> workspace.setContent(new GitHubView());
            case SETTINGS -> workspace.setContent(new SettingsView());
            case ABOUT -> workspace.setContent(new AboutView());
            case WORKSPACE -> {
                if (projectWorkspace == null) {
                    projectWorkspace = new ProjectWorkspace();
                }
                workspace.setContent(projectWorkspace);
            }
        }
    }

    public void navigateWithProject(NavigationTarget target, File projectRoot) {
        if (workspace == null || projectRoot == null) return;

        if (target == NavigationTarget.WORKSPACE) {
            new PersistenceService().saveLastProjectPath(projectRoot.getAbsolutePath());
            projectWorkspace = new ProjectWorkspace();
            projectWorkspace.loadProject(projectRoot);
            workspace.setContent(projectWorkspace);
        }
    }

}
package com.projectwizard.core.navigation;

public enum NavigationTarget {
    HOME,
    NEW_PROJECT,
    OPEN_PROJECT,
    TEMPLATES,
    GIT,
    GITHUB,
    SETTINGS,
    ABOUT,
    WORKSPACE
}
package com.projectwizard;

import javafx.application.Application;
import javafx.stage.Stage;

public class Main extends Application {

    private final App app = new App();

    @Override
    public void start(Stage stage) {

        app.start(stage);

    }

    public static void main(String[] args) {

        launch(args);

    }

}