Editor UI

app-spi/src/main/java/com/basic4gl/desktop/spi/BookmarkInfo.java

@@ -0,0 +1,3 @@
+package com.basic4gl.desktop.spi;
+
+public record BookmarkInfo(String filePath, String fileName, int lineNumber, String lineText) {}

app-spi/src/main/java/com/basic4gl/desktop/spi/DebugController.java

@@ -0,0 +1,11 @@
+package com.basic4gl.desktop.spi;
+
+public interface DebugController {
+    void actionPlayPause();
+
+    void actionStep();
+
+    void actionStepInto();
+
+    void actionStepOutOf();
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/DialogService.java

@@ -7,5 +7,7 @@ public interface DialogService {
     //    JComponent createContent(DialogContext context);
     //    Boolean getResult();
     //    default boolean validate() { return true; }
-    public boolean showDialog(PluginContext context);
+    public void showDialog(String message);
+
+    String showInputDialog(String message, String title, String initialValue);
 }

app-spi/src/main/java/com/basic4gl/desktop/spi/EditorCommandsService.java

@@ -0,0 +1,26 @@
+package com.basic4gl.desktop.spi;
+
+import java.io.File;
+import java.util.List;
+
+public interface EditorCommandsService {
+    void openFileWithPreferredViewer(File file);
+
+    public String collectAllSourceText();
+
+    void actionOpenFolder();
+
+    void selectNextBookmark();
+
+    void selectPreviousBookmark();
+
+    void toggleBookmark();
+
+    List<BookmarkInfo> listBookmarks();
+
+    void goToBookmark(String filePath, int lineNumber);
+
+    void setWorkspaceDirectory(File selectedFile);
+
+    void insertText(String text, int caretOffset);
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/PluginContext.java

@@ -1,12 +1,21 @@
 package com.basic4gl.desktop.spi;
 
+import com.basic4gl.desktop.spi.content.ContentService;
+
 public interface PluginContext {
     //    CommandRegistry commands();
     //    MenuRegistry menus();
     //    ToolWindowRegistry toolWindows();
+
+    EditorCommandsService commands();
+
+    DebugController debugger();
+
     DialogService dialogs();
 
     MenuService menus();
+
+    ContentService content();
     //    ProjectService projects();
     //    EditorService editors();
     FileOpener files();
@@ -15,6 +24,8 @@ public interface PluginContext {
 
     String currentDirectory();
 
+    EditorPlugin currentEditor();
+
     String getLibraryPath();
 
     SourceFileService[] fileServices();

app-spi/src/main/java/com/basic4gl/desktop/spi/content/ClasspathContentSource.java

@@ -0,0 +1,59 @@
+package com.basic4gl.desktop.spi.content;
+
+import java.io.FileNotFoundException;
+import java.io.IOException;
+import java.io.InputStream;
+import java.nio.charset.StandardCharsets;
+import java.util.Collection;
+import java.util.List;
+import java.util.Objects;
+
+public final class ClasspathContentSource implements ContentSource {
+
+    private final ClassLoader classLoader;
+    private final String rootPrefix;
+    private final List<ContentResource> resources;
+
+    public ClasspathContentSource(ClassLoader classLoader, String rootPrefix, String indexResourcePath)
+            throws IOException {
+        this.classLoader = Objects.requireNonNull(classLoader, "classLoader");
+        this.rootPrefix = normalizePrefix(rootPrefix);
+        String indexPath = ContentPaths.normalize(indexResourcePath);
+        try (InputStream input = classLoader.getResourceAsStream(indexPath)) {
+            if (input == null) {
+                throw new FileNotFoundException("Classpath content index not found: " + indexPath);
+            }
+            this.resources = new String(input.readAllBytes(), StandardCharsets.UTF_8)
+                    .lines()
+                    .map(String::trim)
+                    .filter(line -> !line.isBlank())
+                    .filter(line -> !line.startsWith("#"))
+                    .map(ContentPaths::normalize)
+                    .map(ContentResource::new)
+                    .sorted((left, right) -> left.path().compareToIgnoreCase(right.path()))
+                    .toList();
+        }
+    }
+
+    @Override
+    public InputStream open(String normalizedPath) throws IOException {
+        String safePath = ContentPaths.normalize(normalizedPath);
+        InputStream input = classLoader.getResourceAsStream(rootPrefix + safePath);
+        if (input == null) {
+            throw new FileNotFoundException("Classpath content resource not found: " + safePath);
+        }
+        return input;
+    }
+
+    @Override
+    public Collection<ContentResource> resources() {
+        return resources;
+    }
+
+    private static String normalizePrefix(String rootPrefix) {
+        if (rootPrefix == null || rootPrefix.isBlank()) {
+            return "";
+        }
+        return ContentPaths.normalize(rootPrefix) + "/";
+    }
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/content/Content.java

@@ -0,0 +1,35 @@
+package com.basic4gl.desktop.spi.content;
+
+import java.io.File;
+
+@Deprecated
+public class Content {
+    private String name;
+    private ContentMetadata metadata;
+
+    private File file;
+    private boolean readonly;
+
+    public Content(String name, ContentMetadata metadata, File file, boolean readonly) {
+        this.name = name;
+        this.metadata = metadata != null ? metadata : new ContentMetadata();
+        this.file = file;
+        this.readonly = readonly;
+    }
+
+    public String getName() {
+        return name;
+    }
+
+    public ContentMetadata getMetadata() {
+        return metadata;
+    }
+
+    public File getFile() {
+        return file;
+    }
+
+    public boolean isReadonly() {
+        return readonly;
+    }
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/content/ContentDocument.java

@@ -0,0 +1,12 @@
+package com.basic4gl.desktop.spi.content;
+
+import java.util.Objects;
+
+public record ContentDocument(String mediaType, ContentSource source, String entryPath) {
+
+    public ContentDocument {
+        mediaType = ContentValidation.requireNonBlank(mediaType, "mediaType");
+        source = Objects.requireNonNull(source, "source");
+        entryPath = ContentValidation.requireNonBlank(entryPath, "entryPath");
+    }
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/content/ContentMetadata.java

@@ -0,0 +1,62 @@
+package com.basic4gl.desktop.spi.content;
+
+@Deprecated
+public class ContentMetadata {
+    private String category;
+    private String description;
+    private String[] tags;
+    private String author;
+    private String version;
+
+    public ContentMetadata() {
+        tags = new String[0];
+    }
+
+    public ContentMetadata(String category, String description, String[] tags, String author, String version) {
+        this.category = category;
+        this.description = description;
+        this.tags = tags;
+        this.author = author;
+        this.version = version;
+    }
+
+    public String getCategory() {
+        return category;
+    }
+
+    public void setCategory(String category) {
+        this.category = category;
+    }
+
+    public String getDescription() {
+        return description;
+    }
+
+    public void setDescription(String description) {
+        this.description = description;
+    }
+
+    public String[] getTags() {
+        return tags;
+    }
+
+    public void setTags(String[] tags) {
+        this.tags = tags;
+    }
+
+    public String getAuthor() {
+        return author;
+    }
+
+    public void setAuthor(String author) {
+        this.author = author;
+    }
+
+    public String getVersion() {
+        return version;
+    }
+
+    public void setVersion(String version) {
+        this.version = version;
+    }
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/content/ContentPaths.java

@@ -0,0 +1,63 @@
+package com.basic4gl.desktop.spi.content;
+
+import java.util.ArrayDeque;
+import java.util.Deque;
+import java.util.Locale;
+
+public final class ContentPaths {
+
+    private ContentPaths() {}
+
+    public static String normalize(String path) {
+        rejectUnsafePath(path);
+        String normalizedSeparators = path.replace('\\', '/');
+        Deque<String> segments = new ArrayDeque<>();
+        for (String segment : normalizedSeparators.split("/+")) {
+            if (segment.isEmpty() || ".".equals(segment)) {
+                continue;
+            }
+            if ("..".equals(segment)) {
+                if (segments.isEmpty()) {
+                    throw new IllegalArgumentException("Path escapes the content root: " + path);
+                }
+                segments.removeLast();
+                continue;
+            }
+            segments.addLast(segment);
+        }
+        if (segments.isEmpty()) {
+            throw new IllegalArgumentException("Path must not resolve to the content root");
+        }
+        return String.join("/", segments);
+    }
+
+    public static String resolve(String currentDocumentPath, String relativeTarget) {
+        String currentPath = normalize(currentDocumentPath);
+        rejectUnsafePath(relativeTarget);
+        String parent = "";
+        int lastSlash = currentPath.lastIndexOf('/');
+        if (lastSlash >= 0) {
+            parent = currentPath.substring(0, lastSlash);
+        }
+        String combined = parent.isBlank() ? relativeTarget : parent + "/" + relativeTarget;
+        return normalize(combined);
+    }
+
+    private static void rejectUnsafePath(String path) {
+        if (path == null || path.isBlank()) {
+            throw new IllegalArgumentException("Path must not be null or blank");
+        }
+        String trimmed = path.trim();
+        String slashPath = trimmed.replace('\\', '/');
+        if (slashPath.startsWith("/") || slashPath.startsWith("//")) {
+            throw new IllegalArgumentException("Absolute paths are not allowed: " + path);
+        }
+        if (slashPath.matches("^[A-Za-z]:($|/.*)")) {
+            throw new IllegalArgumentException("Windows absolute paths are not allowed: " + path);
+        }
+        String lower = slashPath.toLowerCase(Locale.ROOT);
+        if (lower.matches("^[a-z][a-z0-9+.-]*:.*")) {
+            throw new IllegalArgumentException("URI schemes are not allowed: " + path);
+        }
+    }
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/content/ContentRegistration.java

@@ -0,0 +1,7 @@
+package com.basic4gl.desktop.spi.content;
+
+public interface ContentRegistration extends AutoCloseable {
+
+    @Override
+    void close();
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/content/ContentResource.java

@@ -0,0 +1,8 @@
+package com.basic4gl.desktop.spi.content;
+
+public record ContentResource(String path) {
+
+    public ContentResource {
+        path = ContentValidation.requireNonBlank(path, "path");
+    }
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/content/ContentService.java

@@ -0,0 +1,17 @@
+package com.basic4gl.desktop.spi.content;
+
+public interface ContentService {
+    ContentRegistration registerDocumentProvider(DocumentProvider provider);
+
+    ContentRegistration registerTemplateProvider(TemplateProvider provider);
+
+    @Deprecated
+    default void registerTemplate(Template template) {
+        registerTemplateProvider(new LegacyTemplateProvider(template));
+    }
+
+    @Deprecated
+    default void registerDocument(Content content) {
+        registerDocumentProvider(new LegacyContentDocumentProvider(content));
+    }
+}

app-spi/src/main/java/com/basic4gl/desktop/spi/content/ContentSource.java

@@ -0,0 +1,18 @@
+package com.basic4gl.desktop.spi.content;
+
+import java.io.IOException;
+import java.io.InputStream;
+import java.util.Collection;
+
+public interface ContentSource {
+
+    /**
+     * Opens a normalized path relative to this source's root.
+     */
+    InputStream open(String normalizedPath) throws IOException;
+
+    /**
+     * Returns all files belonging to this content bundle.
+     */
+    Collection<ContentResource> resources() throws IOException;
+}