@eclipse-lyra/core 0.0.0

package/src/commands/files.ts

@@ -0,0 +1,425 @@
+import {registerAll, type ExecutionContext} from "../core/commandregistry";
+import {File, workspaceService, Directory} from "../core/filesys";
+import {toastError, toastInfo} from "../core/toast";
+import {activeSelectionSignal} from "../core/appstate";
+import {editorRegistry, EditorContentProvider} from "../core/editorregistry";
+import logger from "../core/logger";
+
+async function getWorkspaceAndPath(params: any, requirePath: boolean = true): Promise<{workspace: Directory, path: string} | null> {
+    const workspace = await workspaceService.getWorkspace()
+    if (!workspace) {
+        return null
+    }
+
+    const path = params?.path
+    if (requirePath && !path) {
+        return null
+    }
+
+    return { workspace, path: path || '' }
+}
+
+/**
+ * Type guard to check if an editor implements EditorContentProvider
+ */
+function isEditorContentProvider(editor: any): editor is EditorContentProvider {
+    return editor &&
+        typeof editor.getContent === 'function' &&
+        typeof editor.getSelection === 'function' &&
+        typeof editor.getSnippet === 'function' &&
+        typeof editor.getLanguage === 'function' &&
+        typeof editor.getFilePath === 'function';
+}
+
+/**
+ * Helper to get a resource from path or active selection
+ */
+async function getResourceFromContext(context: ExecutionContext, params?: any): Promise<any> {
+    let resource = undefined
+    const path = params?.path || context.params?.["path"]
+    
+    if (path) {
+        const workspaceDir = await workspaceService.getWorkspace()
+        if (workspaceDir) {
+            resource = await workspaceDir.getResource(path)
+        }
+    }
+
+    if (!resource) {
+        resource = activeSelectionSignal.get()
+    }
+
+    return resource
+}
+
+/**
+ * Helper to read text file contents with error handling
+ */
+async function readTextFile(file: File): Promise<string | null> {
+    try {
+        const contents = await file.getContents()
+        if (typeof contents !== 'string') {
+            toastError("File is not a text file")
+            return null
+        }
+        return contents
+    } catch (err: any) {
+        toastError(`Failed to read file: ${err.message}`)
+        return null
+    }
+}
+
+/**
+ * Helper to create null editor response
+ */
+function createNullEditorResponse(includeCursorLine: boolean = false) {
+    const base = {
+        filePath: null,
+        language: null
+    }
+    if (includeCursorLine) {
+        return { ...base, snippet: null, cursorLine: null }
+    }
+    return base
+}
+
+async function getWorkspaceAndFile(params: any, requirePath: boolean = true): Promise<{workspace: Directory, path: string, file: File} | null> {
+    const result = await getWorkspaceAndPath(params, requirePath)
+    if (!result) {
+        return null
+    }
+
+    const { workspace, path } = result
+
+    if (!path) {
+        return null
+    }
+
+    try {
+        const resource = await workspace.getResource(path)
+        if (!resource || !(resource instanceof File)) {
+            return null
+        }
+
+        return { workspace, path, file: resource }
+    } catch (err: any) {
+        return null
+    }
+}
+
+registerAll({
+    command: {
+        "id": "disconnect_folder",
+        "name": "Disconnect folder",
+        "description": "Disconnects a folder from the workspace"
+    },
+    handler: {
+        execute: async () => {
+            const selection = activeSelectionSignal.get()
+            if (!(selection instanceof Directory && selection.getParent() === undefined)) {
+                toastError("Select a folder root to disconnect.")
+                return
+            }
+            try {
+                await workspaceService.disconnectFolder(selection)
+            } catch (err: any) {
+                toastError(err.message)
+            }
+        }
+    },
+    contribution: {
+        target: "contextmenu:filebrowser",
+        label: "Disconnect folder",
+        icon: "folder-minus",
+        disabled: () => {
+            const selection = activeSelectionSignal.get();
+            return !(selection instanceof Directory && selection.getParent() === undefined);
+        }
+    }
+})
+
+// Register local filesystem workspace contribution
+registerAll({
+    command: {
+        "id": "load_workspace",
+        "name": "Local Folder",
+        "description": "Connect to a local folder using File System Access API",
+        "parameters": []
+    },
+    handler: {
+        execute: async _context => {
+            // @ts-ignore
+            await window.showDirectoryPicker({
+                mode: "readwrite"
+            }).then((dirHandle: FileSystemDirectoryHandle) => {
+                return workspaceService.connectWorkspace(dirHandle);
+            }).catch((err: Error) => {
+                toastError(err.message)
+            });
+        }
+    },
+    contribution: {
+        target: "filebrowser.connections",
+        label: "Local Folder",
+        icon: "folder-open"
+    }
+})
+
+registerAll({
+    command: {
+        "id": "connect_opfs",
+        "name": "OPFS",
+        "description": "Connect to Origin Private File System (browser storage)",
+        "parameters": []
+    },
+    handler: {
+        execute: async () => {
+            try {
+                await workspaceService.connectFolder({ opfs: true });
+            } catch (err: any) {
+                toastError(err.message);
+            }
+        }
+    },
+    contribution: {
+        target: "filebrowser.connections",
+        label: "OPFS (Browser Storage)",
+        icon: "database"
+    }
+})
+
+registerAll({
+    command: {
+        "id": "connect_indexeddb",
+        "name": "IndexedDB",
+        "description": "Connect to IndexedDB-backed workspace (browser storage)",
+        "parameters": [
+            {
+                "name": "name",
+                "description": "Optional display name for this IndexedDB workspace root",
+                "required": false
+            }
+        ]
+    },
+    handler: {
+        execute: async (context: ExecutionContext) => {
+            const nameParam = context.params?.["name"];
+            try {
+                await workspaceService.connectFolder({ indexeddb: true, name: nameParam });
+            } catch (err: any) {
+                toastError(err.message);
+            }
+        }
+    },
+    contribution: {
+        target: "filebrowser.connections",
+        label: "IndexedDB (Browser Storage)",
+        icon: "database"
+    }
+})
+
+registerAll({
+    command: {
+        "id": "refresh_resource",
+        "name": "Refresh resource",
+        "description": "Refreshes the connected folder of the selected resource, or the whole workspace if nothing is selected",
+        "parameters": []
+    },
+    handler: {
+        execute: async () => {
+            const selection = activeSelectionSignal.get()
+            if (selection) {
+                selection.getWorkspace().touch()
+                return
+            }
+            const workspace = await workspaceService.getWorkspace()
+            if (!workspace) {
+                toastError("No workspace selected.")
+                return
+            }
+            workspace.touch()
+        }
+    }
+})
+
+registerAll({
+    command: {
+        "id": "open_editor",
+        "name": "Open editor",
+        "description": "Opens a file in an editor",
+        "parameters": [
+            {
+                "name": "path",
+                "description": "The path of the file to open within the workspace; if omitted, the active selection is opened",
+                "required": false
+            },
+            {
+                "name": "editorId",
+                "description": "Open with this editor id; if omitted, use default editor",
+                "required": false
+            }
+        ]
+    },
+    handler: {
+        execute: async context => {
+            const path = context.params?.["path"]
+            const editorId = context.params?.["editorId"]
+            let file: File | null = null
+            if (path) {
+                const result = await getWorkspaceAndFile({ path })
+                file = result?.file ?? null
+            } else {
+                const selection = activeSelectionSignal.get()
+                file = selection instanceof File ? selection : null
+            }
+            if (!file) return
+            await editorRegistry.loadEditor(file, editorId)
+        }
+    }
+})
+
+registerAll({
+    command: {
+        "id": "get_active_editor_content",
+        "name": "Get active editor content",
+        "description": "Gets the complete contents of the currently active editor. Returns null if no editor is active or if the editor is not a code editor.",
+        "parameters": [],
+        "output": [
+            {
+                "name": "content",
+                "description": "the complete contents of the active editor, or null if no editor is active"
+            },
+            {
+                "name": "filePath",
+                "description": "the workspace path of the file in the active editor, or null if no editor is active"
+            },
+            {
+                "name": "language",
+                "description": "the programming language of the active editor, or null if no editor is active"
+            }
+        ]
+    },
+    handler: {
+        execute: async (context: ExecutionContext) => {
+            const activeEditor = context.activeEditor as any
+            if (!isEditorContentProvider(activeEditor)) {
+                return { ...createNullEditorResponse(), content: null }
+            }
+
+            try {
+                return {
+                    content: activeEditor.getContent(),
+                    filePath: activeEditor.getFilePath(),
+                    language: activeEditor.getLanguage()
+                }
+            } catch (err: any) {
+                return { ...createNullEditorResponse(), content: null }
+            }
+        }
+    }
+})
+
+registerAll({
+    command: {
+        "id": "get_active_editor_selection",
+        "name": "Get active editor selection",
+        "description": "Gets the currently selected text in the active editor. Returns null if no editor is active, no selection exists, or if the editor is not a code editor.",
+        "parameters": [],
+        "output": [
+            {
+                "name": "selection",
+                "description": "the selected text in the active editor, or null if no selection exists or no editor is active"
+            },
+            {
+                "name": "filePath",
+                "description": "the workspace path of the file in the active editor, or null if no editor is active"
+            },
+            {
+                "name": "language",
+                "description": "the programming language of the active editor, or null if no editor is active"
+            }
+        ]
+    },
+    handler: {
+        execute: async (context: ExecutionContext) => {
+            const activeEditor = context.activeEditor as any
+            if (!isEditorContentProvider(activeEditor)) {
+                return { ...createNullEditorResponse(), selection: null }
+            }
+
+            try {
+                return {
+                    selection: activeEditor.getSelection(),
+                    filePath: activeEditor.getFilePath(),
+                    language: activeEditor.getLanguage()
+                }
+            } catch (err: any) {
+                return { ...createNullEditorResponse(), selection: null }
+            }
+        }
+    }
+})
+
+registerAll({
+    command: {
+        "id": "get_active_editor_snippet",
+        "name": "Get active editor snippet around cursor",
+        "description": "Gets a code snippet from the active editor with n lines before and n lines after the cursor position. Useful for getting context around the cursor without loading the entire file.",
+        "parameters": [
+            {
+                "name": "lines",
+                "description": "number of lines to include before and after the cursor position (default: 5)",
+                "type": "number",
+                "required": false
+            }
+        ],
+        "output": [
+            {
+                "name": "snippet",
+                "description": "the code snippet with n lines before and after the cursor, or null if no editor is active"
+            },
+            {
+                "name": "filePath",
+                "description": "the workspace path of the file in the active editor, or null if no editor is active"
+            },
+            {
+                "name": "language",
+                "description": "the programming language of the active editor, or null if no editor is active"
+            },
+            {
+                "name": "cursorLine",
+                "description": "the line number where the cursor is positioned (1-based), or null if no editor is active"
+            }
+        ]
+    },
+    handler: {
+        execute: async (context: ExecutionContext) => {
+            const activeEditor = context.activeEditor as any
+            if (!isEditorContentProvider(activeEditor)) {
+                return createNullEditorResponse(true)
+            }
+
+            try {
+                const numLines = context.params?.lines ? parseInt(context.params.lines, 10) : 5
+                if (isNaN(numLines) || numLines < 0) {
+                    return createNullEditorResponse(true)
+                }
+
+                const snippetResult = activeEditor.getSnippet(numLines)
+                if (!snippetResult) {
+                    return createNullEditorResponse(true)
+                }
+
+                return {
+                    snippet: snippetResult.snippet,
+                    filePath: activeEditor.getFilePath(),
+                    language: activeEditor.getLanguage(),
+                    cursorLine: snippetResult.cursorLine
+                }
+            } catch (err: any) {
+                return createNullEditorResponse(true)
+            }
+        }
+    }
+})
+

package/src/commands/global.ts

@@ -0,0 +1,198 @@
+import { registerAll } from "../core/commandregistry";
+import { CommandContribution } from "../core/contributionregistry";
+import { TOOLBAR_MAIN_RIGHT } from "../core/constants";
+import { EditorInput, editorRegistry } from "../core/editorregistry";
+import { html } from "lit";
+import { toastError, toastInfo } from "../core/toast";
+import { activeEditorSignal, activePartSignal } from "../core/appstate";
+import { appSettings } from "../core/settingsservice";
+import { extensionRegistry } from "../core/extensionregistry";
+import type { Extension } from "../core/extensionregistry";
+import { marketplaceRegistry } from "../core/marketplaceregistry";
+import "./files";
+import "./version-info";
+
+registerAll({
+    command: {
+        "id": "save",
+        "name": "Save editor",
+        "description": "Saves the active/focused editor",
+        "keyBinding": "CTRL+S",
+        "parameters": []
+    },
+    handler: {
+        execute: async _context => {
+            const part = activeEditorSignal.get() || activePartSignal.get()
+            if (part && part.isDirty()) {
+                part.save()
+            }
+        }
+    },
+    contribution: {
+        target: "toolbar:.system.editors",
+        icon: "floppy-disk",
+        label: "Save active editor",
+        slot: "start",
+        disabled: () => {
+            const part = activePartSignal.get()
+            return !part || !part.isDirty()
+        }
+    } as CommandContribution
+})
+
+const THEME_SETTINGS_KEY = "theme"
+
+async function applyTheme(themeClass: 'wa-dark' | 'wa-light'): Promise<void> {
+    const root = document.documentElement
+    root.classList.remove('wa-dark', 'wa-light')
+    root.classList.add(themeClass)
+}
+
+async function loadTheme(): Promise<void> {
+    const theme = await appSettings.get(THEME_SETTINGS_KEY)
+    await applyTheme(theme || 'wa-dark')
+}
+
+async function saveTheme(themeClass: 'wa-dark' | 'wa-light'): Promise<void> {
+    await appSettings.set(THEME_SETTINGS_KEY, themeClass)
+}
+
+registerAll({
+    command: {
+        "id": "switch_theme",
+        "name": "Switch theme",
+        "description": "Switches between dark and light theme",
+        "parameters": []
+    },
+    handler: {
+        execute: async _context => {
+            const isDark = document.documentElement.classList.contains("wa-dark")
+            const newTheme = isDark ? 'wa-light' : 'wa-dark'
+            await applyTheme(newTheme)
+            await saveTheme(newTheme)
+        }
+    },
+    contribution: {
+        target: TOOLBAR_MAIN_RIGHT,
+        icon: "circle-half-stroke",
+        label: "Theme Switcher",
+    }
+})
+
+// Load theme on module initialization
+loadTheme().catch(err => {
+    console.error('Failed to load theme preference:', err)
+})
+
+registerAll({
+    command: {
+        "id": "fullscreen",
+        "name": "Toggle fullscreen",
+        "description": "Toggles fullscreen mode",
+        "parameters": []
+    },
+    handler: {
+        execute: async _context => {
+            if (document.fullscreenElement === document.body) {
+                await document.exitFullscreen()
+            } else {
+                await document.body.requestFullscreen()
+            }
+        }
+    },
+    contribution: {
+        target: TOOLBAR_MAIN_RIGHT,
+        icon: "expand",
+        label: "Fullscreen",
+    }
+})
+
+registerAll({
+    command: {
+        "id": "open_extensions",
+        "name": "Open Extensions",
+        "description": "Opens the extensions registry",
+        "parameters": []
+    },
+    handler: {
+        execute: _context => {
+            const editorInput: EditorInput = {
+                title: "Extensions",
+                data: {},
+                key: "system.extensions",
+                icon: "puzzle-piece",
+                state: {},
+                noOverflow: true,
+                widgetFactory: () => html`<lyra-extensions></lyra-extensions>`,
+            }
+            editorRegistry.loadEditor(editorInput, "extensions-editor").then()
+        }
+    },
+    contribution: {
+        target: TOOLBAR_MAIN_RIGHT,
+        icon: "puzzle-piece",
+        label: "Open Extensions",
+    }
+})
+
+registerAll({
+    command: {
+        "id": "list_extensions",
+        "name": "List extensions",
+        "description": "Lists all available extensions with their status (enabled/disabled)",
+        "parameters": [],
+        "output": [
+            {
+                "name": "extensions",
+                "description": "array of extension objects with id, name, description, experimental flag, and enabled status"
+            }
+        ]
+    },
+    handler: {
+        execute: async (_context: any) => {
+            const extensions = extensionRegistry.getExtensions().map((e: Extension) => {
+                return {
+                    id: e.id,
+                    name: e.name,
+                    description: e.description,
+                    experimental: e.experimental,
+                    enabled: extensionRegistry.isEnabled(e.id)
+                }
+            });
+            return extensions;
+        }
+    }
+})
+
+registerAll({
+    command: {
+        "id": "toast_message",
+        "name": "Toast message to user",
+        "description": "Shows a toast message",
+        "parameters": [
+            {
+                "name": "message",
+                "description": "the message to toast",
+                "required": true
+            },
+            {
+                "name": "type",
+                "description": "the toast type: info (default), or error",
+                "required": false
+            }
+        ]
+    },
+    handler: {
+        execute: ({ params: { message, type } }: any) => {
+            if (!message) {
+                return
+            }
+            if (type === "error") {
+                toastError(message)
+            } else {
+                toastInfo(message)
+            }
+        }
+    }
+})
+

package/src/commands/index.ts

@@ -0,0 +1,6 @@
+import "./editor";
+import "./files";
+import "./global";
+import "./open-view-as-editor";
+import "./version-info";
+

package/src/commands/open-view-as-editor.ts

@@ -0,0 +1,28 @@
+import { registerAll } from "../core/commandregistry";
+import { SYSTEM_VIEWS } from "../core/constants";
+import type { TabContribution } from "../core/contributionregistry";
+import { contributionRegistry } from "../core/contributionregistry";
+import { editorRegistry } from "../core/editorregistry";
+
+registerAll({
+    command: {
+        id: "open_view_as_editor",
+        name: "Open view as editor",
+        description: "Opens a dashboard view in the editor area",
+        parameters: [
+            { name: "name", description: "View contribution name", required: true },
+            { name: "sourceContributionSlot", description: "source contribution slot (default: SYSTEM_VIEWS)", required: false }
+        ]
+    },
+    handler: {
+        execute: async ({ params }: { params?: { name?: string, sourceContributionSlot?: string } }) => {
+            const name = params?.name;
+            if (!name) return;
+            const slot = params?.sourceContributionSlot ?? SYSTEM_VIEWS
+            const contributions = contributionRegistry.getContributions(slot) as TabContribution[];
+            const contribution = contributions.find(c => c.name === name);
+            if (!contribution?.component) return;
+            await editorRegistry.openTab(contribution as TabContribution);
+        }
+    }
+});