@workbench-kit/shell-react 0.0.2-prototype.0.2.18 → 0.0.2-prototype.0.2.19

package/src/extensions/builtin/editor/workbench.extension.json

@@ -0,0 +1,32 @@
+{
+  "schemaVersion": 1,
+  "id": "workbench-kit.builtin.editor",
+  "name": "builtin-editor",
+  "displayName": "Text Editor",
+  "version": "0.0.0",
+  "publisher": "workbench-kit",
+  "engines": {
+    "workbench": "^0.0.0",
+    "extensionApi": "^0.0.0"
+  },
+  "activationEvents": ["onStartup"],
+  "contributes": {
+    "documentViews": [
+      {
+        "id": "workbench-kit.builtin.editor.markdown-preview",
+        "kind": "preview",
+        "label": "Preview",
+        "priority": 5,
+        "filenamePatterns": ["*.md", "*.mdx"],
+        "mimeTypes": ["text/markdown"]
+      }
+    ],
+    "editors": [
+      {
+        "id": "workbench-kit.builtin.editor.text",
+        "label": "Text Editor",
+        "icon": "file"
+      }
+    ]
+  }
+}

package/src/extensions/builtin/explorer/src/index.ts

@@ -0,0 +1,466 @@
+import {
+  WORKBENCH_EDITOR_SERVICE_CAPABILITY_ID,
+  type ExtensionContext,
+  type WorkbenchEditorServiceCapability,
+} from '@workbench-kit/workbench-extension-sdk';
+import {
+  WORKBENCH_WORKSPACE_CAPABILITY_ID,
+  createWorkspaceResourceTransaction,
+  fileNameOfPath,
+  formatWorkspaceResourceUri,
+  getAvailableWorkspaceEntryName,
+  getWorkspaceEntryMovePlan,
+  isSimpleWorkspaceName,
+  isWorkspaceEntryPathAvailable,
+  joinWorkspacePath,
+  normalizeWorkspacePath,
+  parentPathOf,
+  type VirtualWorkspaceState,
+  type VirtualWorkspaceInitialState,
+  type WorkspaceResourceMutation,
+  type WorkspaceResourceService,
+  type WorkspaceFile,
+} from '@workbench-kit/workspace';
+
+export const EXTENSION_ID = 'workbench-kit.builtin.explorer' as const;
+
+export const EXPLORER_VIEW_ID = 'workbench-kit.builtin.explorer.tree' as const;
+export const EXPLORER_VIEW_RENDER_KIND = 'workbench-kit.builtin.explorer.view' as const;
+export const REFRESH_COMMAND_ID = 'workbench-kit.builtin.explorer.refresh' as const;
+export const REVEAL_COMMAND_ID = 'workbench-kit.builtin.explorer.reveal' as const;
+export const FOCUS_COMMAND_ID = 'workbench-kit.builtin.explorer.focus' as const;
+export const MOVE_COMMAND_ID = 'workbench-kit.builtin.explorer.move' as const;
+
+const WORKSPACE_NEW_FILE_COMMAND_ID = 'workspace.newFile' as const;
+const WORKSPACE_NEW_FOLDER_COMMAND_ID = 'workspace.newFolder' as const;
+const WORKSPACE_INIT_COMMAND_ID = 'workspace.init' as const;
+const WORKSPACE_OPEN_COMMAND_ID = 'workspace.open' as const;
+const WORKSPACE_COPY_PATH_COMMAND_ID = 'workspace.copyPath' as const;
+const WORKSPACE_RENAME_COMMAND_ID = 'workspace.rename' as const;
+const WORKSPACE_DELETE_COMMAND_ID = 'workspace.delete' as const;
+
+interface ExplorerViewRenderData {
+  readonly kind: typeof EXPLORER_VIEW_RENDER_KIND;
+}
+
+interface WorkspaceCommandResult {
+  readonly path?: string | undefined;
+  readonly paths?: readonly string[] | undefined;
+  readonly transactionId?: string | undefined;
+}
+
+export function activate(context: ExtensionContext): void {
+  context.commands.registerCommand(REFRESH_COMMAND_ID, () => {
+    const service = getWorkspaceService(context);
+    return {
+      refreshed: true,
+      version: service?.getSnapshot().version,
+      viewId: EXPLORER_VIEW_ID,
+    };
+  });
+
+  context.commands.registerCommand(REVEAL_COMMAND_ID, (input) => ({
+    path: readFirstPath(input),
+    viewId: EXPLORER_VIEW_ID,
+  }));
+
+  context.commands.registerCommand(FOCUS_COMMAND_ID, () => ({
+    focused: true,
+    viewId: EXPLORER_VIEW_ID,
+  }));
+
+  context.commands.registerCommand(WORKSPACE_NEW_FILE_COMMAND_ID, (input) =>
+    createWorkspaceFile(context, input),
+  );
+
+  context.commands.registerCommand(WORKSPACE_NEW_FOLDER_COMMAND_ID, (input) =>
+    createWorkspaceFolder(context, input),
+  );
+
+  context.commands.registerCommand(WORKSPACE_INIT_COMMAND_ID, (input) =>
+    initializeWorkspace(context, input),
+  );
+
+  context.commands.registerCommand(WORKSPACE_OPEN_COMMAND_ID, (input) =>
+    openWorkspaceTargets(context, input),
+  );
+
+  context.commands.registerCommand(WORKSPACE_COPY_PATH_COMMAND_ID, (input) =>
+    copyWorkspacePaths(input),
+  );
+
+  context.commands.registerCommand(WORKSPACE_RENAME_COMMAND_ID, (input) =>
+    renameWorkspaceTarget(context, input),
+  );
+
+  context.commands.registerCommand(WORKSPACE_DELETE_COMMAND_ID, (input) =>
+    deleteWorkspaceTargets(context, input),
+  );
+
+  context.commands.registerCommand(MOVE_COMMAND_ID, (input) =>
+    moveWorkspaceTargets(context, input),
+  );
+
+  context.views.registerViewProvider({
+    viewId: EXPLORER_VIEW_ID,
+    resolveViewHost: () => ({
+      dispose() {},
+      render: (): ExplorerViewRenderData => ({ kind: EXPLORER_VIEW_RENDER_KIND }),
+      title: 'Explorer',
+    }),
+  });
+}
+
+function createWorkspaceFile(
+  context: ExtensionContext,
+  input: unknown,
+): WorkspaceCommandResult | undefined {
+  const service = getWorkspaceService(context);
+  if (!service) return undefined;
+
+  const state = service.getState();
+  const parentPath = normalizeWorkspacePath(readString(input, 'parentPath') ?? '');
+  const explicitPath = normalizeWorkspacePath(readString(input, 'path') ?? '');
+  const path =
+    explicitPath ||
+    resolveNewEntryPath({
+      fallbackName: 'untitled.md',
+      input,
+      parentPath,
+      state,
+    });
+
+  if (
+    !path ||
+    !isWorkspaceEntryPathAvailable({ files: state.files, folders: state.folders, path })
+  ) {
+    return undefined;
+  }
+
+  return applyMutations(service, 'Create file', [
+    {
+      file: {
+        content: '',
+        path,
+        source: 'user',
+      },
+      path,
+      type: 'create-file',
+    },
+  ]);
+}
+
+function createWorkspaceFolder(
+  context: ExtensionContext,
+  input: unknown,
+): WorkspaceCommandResult | undefined {
+  const service = getWorkspaceService(context);
+  if (!service) return undefined;
+
+  const state = service.getState();
+  const parentPath = normalizeWorkspacePath(readString(input, 'parentPath') ?? '');
+  const explicitPath = normalizeWorkspacePath(readString(input, 'path') ?? '');
+  const path =
+    explicitPath ||
+    resolveNewEntryPath({
+      fallbackName: 'new-folder',
+      input,
+      parentPath,
+      state,
+    });
+
+  if (
+    !path ||
+    !isWorkspaceEntryPathAvailable({ files: state.files, folders: state.folders, path })
+  ) {
+    return undefined;
+  }
+
+  return applyMutations(service, 'Create folder', [{ path, type: 'create-folder' }]);
+}
+
+function initializeWorkspace(
+  context: ExtensionContext,
+  input: unknown,
+): WorkspaceCommandResult | undefined {
+  const service = getWorkspaceService(context);
+  if (!service) return undefined;
+
+  const initialState = readWorkspaceInitialState(input);
+  return applyMutations(
+    service,
+    'Initialize workspace',
+    [{ type: 'initialize-workspace', state: initialState }],
+    {
+      paths: [
+        ...readStringArray(input, 'folders'),
+        ...readWorkspaceFiles(input).map((file) => file.path),
+      ],
+    },
+  );
+}
+
+function openWorkspaceTargets(
+  context: ExtensionContext,
+  input: unknown,
+): WorkspaceCommandResult | undefined {
+  const service = getWorkspaceService(context);
+  const editorService = context.getCapability<WorkbenchEditorServiceCapability>(
+    WORKBENCH_EDITOR_SERVICE_CAPABILITY_ID,
+  );
+  if (!service || !editorService) return undefined;
+
+  const fileByPath = new Map(service.getState().files.map((file) => [file.path, file]));
+  const paths = readPaths(input).filter((path) => fileByPath.has(path));
+  for (const path of paths) {
+    const file = fileByPath.get(path);
+    editorService.openEditor({
+      pinned: true,
+      resourceUri: formatWorkspaceResourceUri({ kind: 'file', path }),
+      title: file ? fileNameOfPath(file.path) : fileNameOfPath(path),
+    });
+  }
+
+  return paths.length > 0 ? { paths } : undefined;
+}
+
+function copyWorkspacePaths(input: unknown): WorkspaceCommandResult | undefined {
+  const paths = readPaths(input);
+  if (paths.length === 0) return undefined;
+
+  const clipboard = globalThis.navigator?.clipboard;
+  if (clipboard) {
+    void clipboard.writeText(paths.join('\n')).catch(() => undefined);
+  }
+
+  return { paths };
+}
+
+function renameWorkspaceTarget(
+  context: ExtensionContext,
+  input: unknown,
+): WorkspaceCommandResult | undefined {
+  const service = getWorkspaceService(context);
+  if (!service) return undefined;
+
+  const state = service.getState();
+  const path = readFirstPath(input);
+  const name = readString(input, 'name')?.trim();
+  if (!path || !name || !isSimpleWorkspaceName(name)) {
+    return undefined;
+  }
+
+  const destinationPath = joinWorkspacePath(parentPathOf(path), name);
+  if (
+    !destinationPath ||
+    !isWorkspaceEntryPathAvailable({
+      excludedPaths: [path],
+      files: state.files,
+      folders: state.folders,
+      path: destinationPath,
+    })
+  ) {
+    return undefined;
+  }
+
+  const kind =
+    readString(input, 'kind') === 'folder' ? 'folder' : resolveWorkspacePathKind(state, path);
+  if (!kind) return undefined;
+
+  return applyMutations(
+    service,
+    kind === 'folder' ? 'Rename folder' : 'Rename file',
+    [
+      kind === 'folder'
+        ? { name, path, type: 'rename-folder' }
+        : { name, path, type: 'rename-file' },
+    ],
+    { path: destinationPath, paths: [destinationPath] },
+  );
+}
+
+function deleteWorkspaceTargets(
+  context: ExtensionContext,
+  input: unknown,
+): WorkspaceCommandResult | undefined {
+  const service = getWorkspaceService(context);
+  if (!service) return undefined;
+
+  const state = service.getState();
+  const mutations = readPaths(input)
+    .map((path): WorkspaceResourceMutation | undefined => {
+      const kind =
+        readString(input, 'kind') === 'folder' ? 'folder' : resolveWorkspacePathKind(state, path);
+      if (kind === 'folder') {
+        return { path, type: 'delete-folder' };
+      }
+
+      if (kind === 'file') {
+        return { path, type: 'delete-file' };
+      }
+
+      return undefined;
+    })
+    .filter((mutation): mutation is WorkspaceResourceMutation => Boolean(mutation));
+
+  if (mutations.length === 0) return undefined;
+
+  return applyMutations(service, 'Delete workspace entries', mutations, { paths: [] });
+}
+
+function moveWorkspaceTargets(
+  context: ExtensionContext,
+  input: unknown,
+): WorkspaceCommandResult | undefined {
+  const service = getWorkspaceService(context);
+  if (!service) return undefined;
+
+  const state = service.getState();
+  const targetFolderPath = normalizeWorkspacePath(readString(input, 'targetFolderPath') ?? '');
+  const plan = getWorkspaceEntryMovePlan({
+    files: state.files,
+    folders: state.folders,
+    sourcePaths: readStringArray(input, 'sourcePaths'),
+    targetFolderPath,
+  });
+  const mutations = plan.moves.map<WorkspaceResourceMutation>((move) =>
+    move.kind === 'folder'
+      ? {
+          sourcePath: move.sourcePath,
+          targetFolderPath: plan.targetFolderPath,
+          type: 'move-folder',
+        }
+      : {
+          sourcePath: move.sourcePath,
+          targetFolderPath: plan.targetFolderPath,
+          type: 'move-file',
+        },
+  );
+
+  if (mutations.length === 0) return undefined;
+
+  return applyMutations(service, 'Move workspace entries', mutations, {
+    paths: plan.moves.map((move) => move.destinationPath),
+  });
+}
+
+function applyMutations(
+  service: WorkspaceResourceService,
+  label: string,
+  mutations: readonly WorkspaceResourceMutation[],
+  result: Omit<WorkspaceCommandResult, 'transactionId'> = {},
+): WorkspaceCommandResult {
+  const transaction = createWorkspaceResourceTransaction({ label, mutations });
+  service.applyTransaction(transaction);
+
+  const mutationPaths = mutations.flatMap((mutation) => {
+    if ('path' in mutation) return [mutation.path];
+    if (mutation.type === 'move-file') return [mutation.sourcePath];
+    if (mutation.type === 'move-folder') return [mutation.sourcePath];
+    return [];
+  });
+
+  return {
+    path: result.path ?? result.paths?.[0] ?? mutationPaths[0],
+    paths: result.paths ?? mutationPaths,
+    transactionId: transaction.id,
+  };
+}
+
+function resolveNewEntryPath({
+  fallbackName,
+  input,
+  parentPath,
+  state,
+}: {
+  fallbackName: string;
+  input: unknown;
+  parentPath: string;
+  state: VirtualWorkspaceState;
+}): string {
+  const preferredName = readString(input, 'name')?.trim() || fallbackName;
+  if (!isSimpleWorkspaceName(preferredName)) return '';
+
+  const name = getAvailableWorkspaceEntryName({
+    files: state.files,
+    folders: state.folders,
+    parentPath,
+    preferredName,
+  });
+
+  return joinWorkspacePath(parentPath, name);
+}
+
+function getWorkspaceService(context: ExtensionContext): WorkspaceResourceService | undefined {
+  return context.getCapability<WorkspaceResourceService>(WORKBENCH_WORKSPACE_CAPABILITY_ID);
+}
+
+function resolveWorkspacePathKind(
+  state: VirtualWorkspaceState,
+  path: string,
+): 'file' | 'folder' | undefined {
+  if (state.files.some((file) => file.path === path)) return 'file';
+  if (state.folders.includes(path)) return 'folder';
+  return undefined;
+}
+
+function readFirstPath(input: unknown): string | undefined {
+  return readPaths(input)[0];
+}
+
+function readPaths(input: unknown): string[] {
+  const paths = readStringArray(input, 'paths');
+  const path = readString(input, 'path');
+  const allPaths = path ? [path, ...paths] : paths;
+
+  return [...new Set(allPaths.map(normalizeWorkspacePath).filter(Boolean))];
+}
+
+function readStringArray(input: unknown, key: string): string[] {
+  const value = isRecord(input) ? input[key] : undefined;
+  if (!Array.isArray(value)) return [];
+
+  return value.filter((entry): entry is string => typeof entry === 'string');
+}
+
+function readWorkspaceInitialState(input: unknown): VirtualWorkspaceInitialState {
+  return {
+    expandedPaths: readStringArray(input, 'expandedPaths'),
+    files: readWorkspaceFiles(input),
+    folders: readStringArray(input, 'folders'),
+    openPaths: readStringArray(input, 'openPaths'),
+    searchQuery: readString(input, 'searchQuery') ?? '',
+    selectedPath: readString(input, 'selectedPath'),
+  };
+}
+
+function readWorkspaceFiles(input: unknown): WorkspaceFile[] {
+  const value = isRecord(input) ? input.files : undefined;
+  if (!Array.isArray(value)) return [];
+
+  return value.flatMap((entry) => {
+    if (!isRecord(entry)) return [];
+
+    const path = typeof entry.path === 'string' ? entry.path : '';
+    if (!path) return [];
+
+    return [
+      {
+        content: typeof entry.content === 'string' ? entry.content : '',
+        mimeType: typeof entry.mimeType === 'string' ? entry.mimeType : undefined,
+        path,
+        source: entry.source === 'assistant' || entry.source === 'user' ? entry.source : undefined,
+        updatedAt: typeof entry.updatedAt === 'string' ? entry.updatedAt : undefined,
+      },
+    ];
+  });
+}
+
+function readString(input: unknown, key: string): string | undefined {
+  const value = isRecord(input) ? input[key] : undefined;
+  return typeof value === 'string' ? value : undefined;
+}
+
+function isRecord(value: unknown): value is Record<string, unknown> {
+  return typeof value === 'object' && value !== null;
+}

package/src/extensions/builtin/explorer/workbench.extension.json

@@ -0,0 +1,132 @@
+{
+  "schemaVersion": 1,
+  "id": "workbench-kit.builtin.explorer",
+  "name": "builtin-explorer",
+  "displayName": "Explorer",
+  "version": "0.0.0",
+  "publisher": "workbench-kit",
+  "engines": {
+    "workbench": "^0.0.0",
+    "extensionApi": "^0.0.0"
+  },
+  "activationEvents": [
+    "onView:workbench-kit.builtin.explorer.tree",
+    "onCommand:workbench-kit.builtin.explorer.refresh",
+    "onCommand:workbench-kit.builtin.explorer.reveal",
+    "onCommand:workbench-kit.builtin.explorer.focus",
+    "onCommand:workbench-kit.builtin.explorer.move",
+    "onCommand:workspace.newFile",
+    "onCommand:workspace.newFolder",
+    "onCommand:workspace.init",
+    "onCommand:workspace.open",
+    "onCommand:workspace.copyPath",
+    "onCommand:workspace.rename",
+    "onCommand:workspace.delete"
+  ],
+  "capabilities": {
+    "requires": ["workbench.workspace"]
+  },
+  "permissions": ["workspace.read", "workspace.write"],
+  "contributes": {
+    "commands": [
+      {
+        "command": "workbench-kit.builtin.explorer.refresh",
+        "title": "Refresh Explorer",
+        "category": "Explorer"
+      },
+      {
+        "command": "workbench-kit.builtin.explorer.reveal",
+        "title": "Reveal in Explorer",
+        "category": "Explorer"
+      },
+      {
+        "command": "workbench-kit.builtin.explorer.focus",
+        "title": "Focus Explorer",
+        "category": "Explorer"
+      },
+      {
+        "command": "workbench-kit.builtin.explorer.move",
+        "title": "Move Workspace Entry",
+        "category": "Explorer"
+      },
+      {
+        "command": "workspace.newFile",
+        "title": "New File",
+        "category": "Workspace",
+        "icon": "new-file"
+      },
+      {
+        "command": "workspace.newFolder",
+        "title": "New Folder",
+        "category": "Workspace",
+        "icon": "new-folder"
+      },
+      {
+        "command": "workspace.init",
+        "title": "Initialize Workspace",
+        "category": "Workspace"
+      },
+      {
+        "command": "workspace.open",
+        "title": "Open",
+        "category": "Workspace",
+        "icon": "go-to-file"
+      },
+      {
+        "command": "workspace.copyPath",
+        "title": "Copy Path",
+        "category": "Workspace",
+        "icon": "copy"
+      },
+      {
+        "command": "workspace.rename",
+        "title": "Rename",
+        "category": "Workspace",
+        "icon": "edit"
+      },
+      {
+        "command": "workspace.delete",
+        "title": "Delete",
+        "category": "Workspace",
+        "icon": "trash"
+      }
+    ],
+    "menus": {
+      "view/title": [
+        {
+          "command": "workbench-kit.builtin.explorer.refresh",
+          "group": "navigation",
+          "order": 1,
+          "when": "view == workbench-kit.builtin.explorer.tree"
+        }
+      ]
+    },
+    "viewContainers": {
+      "activitybar": [
+        {
+          "id": "explorer",
+          "title": "Explorer",
+          "icon": "files",
+          "order": 10
+        }
+      ]
+    },
+    "activities": [
+      {
+        "id": "workbench-kit.builtin.explorer.activity",
+        "viewContainerId": "explorer",
+        "icon": "files",
+        "title": "Explorer",
+        "order": 10
+      }
+    ],
+    "views": {
+      "explorer": [
+        {
+          "id": "workbench-kit.builtin.explorer.tree",
+          "name": "Explorer"
+        }
+      ]
+    }
+  }
+}

package/src/extensions/builtin/extensions/src/index.ts

@@ -0,0 +1,28 @@
+import type { ExtensionContext } from '@workbench-kit/workbench-extension-sdk';
+
+export const EXTENSION_ID = 'workbench-kit.builtin.extensions' as const;
+export const EXTENSIONS_VIEW_ID = 'workbench-kit.builtin.extensions.panel' as const;
+export const EXTENSIONS_VIEW_RENDER_KIND = 'workbench-kit.builtin.extensions.view' as const;
+export const FOCUS_EXTENSIONS_COMMAND_ID = 'workbench-kit.builtin.extensions.focus' as const;
+
+export interface BuiltinExtensionsViewRenderData {
+  readonly kind: typeof EXTENSIONS_VIEW_RENDER_KIND;
+}
+
+export function activate(context: ExtensionContext): void {
+  context.commands.registerCommand(FOCUS_EXTENSIONS_COMMAND_ID, () => ({
+    focused: true,
+    viewId: EXTENSIONS_VIEW_ID,
+  }));
+
+  context.views.registerViewProvider({
+    viewId: EXTENSIONS_VIEW_ID,
+    resolveViewHost: () => ({
+      dispose() {},
+      render: (): BuiltinExtensionsViewRenderData => ({
+        kind: EXTENSIONS_VIEW_RENDER_KIND,
+      }),
+      title: 'Extensions',
+    }),
+  });
+}