@workbench-kit/adapters 0.0.1-prototype.0

package/package.json

@@ -0,0 +1,39 @@
+{
+  "name": "@workbench-kit/adapters",
+  "version": "0.0.1-prototype.0",
+  "private": false,
+  "type": "module",
+  "exports": {
+    ".": "./src/index.ts",
+    "./library": "./src/library.ts",
+    "./runtime": "./src/runtime.ts",
+    "./workspace": "./src/workspace.ts"
+  },
+  "files": [
+    "src",
+    "!src/**/*.test.ts",
+    "!src/**/*.test.tsx",
+    "!src/**/*.stories.ts",
+    "!src/**/*.stories.tsx"
+  ],
+  "dependencies": {
+    "@workbench-kit/contracts": "0.0.1-prototype.0",
+    "@workbench-kit/runtime": "0.0.1-prototype.0",
+    "@workbench-kit/workspace": "0.0.1-prototype.0"
+  },
+  "description": "Workbench Kit adapters for workspace repositories and runtime transports.",
+  "publishConfig": {
+    "access": "public",
+    "tag": "prototype",
+    "provenance": true
+  },
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/NewChoBo/newchobo-ui-package.git",
+    "directory": "packages/adapters"
+  },
+  "scripts": {
+    "test": "vitest run src",
+    "typecheck": "tsc -p tsconfig.json --noEmit"
+  }
+}

package/src/index.ts

@@ -0,0 +1,3 @@
+export * from './runtime';
+export * from './library';
+export * from './workspace';

package/src/library.ts

@@ -0,0 +1,145 @@
+import type { LibraryManifest, LibraryProvider } from '@workbench-kit/contracts';
+import {
+  normalizeLibraryItemProviderSource,
+  parseLibraryManifest,
+  parseLibraryManifestText,
+} from '@workbench-kit/contracts';
+
+type ManifestTextLoader = () => Promise<string> | string;
+
+export interface LibraryManifestProviderOptions {
+  displayName: string;
+  id: string;
+  loadManifestText: ManifestTextLoader;
+}
+
+export interface StaticLibraryManifestProviderOptions {
+  displayName: string;
+  id: string;
+  manifestText: string;
+}
+
+export interface ObjectLibraryManifestProviderOptions {
+  displayName: string;
+  id: string;
+  manifest: unknown;
+}
+
+export interface HttpLibraryManifestProviderOptions {
+  displayName: string;
+  id: string;
+  manifestUrl: string;
+  readText?: (url: string) => Promise<string>;
+}
+
+export function createLibraryManifestProvider({
+  displayName,
+  id,
+  loadManifestText,
+}: LibraryManifestProviderOptions): LibraryProvider {
+  return {
+    displayName,
+    id,
+    async listItems() {
+      const manifest = parseLibraryManifestSourceText(id, await loadManifestText());
+      return manifest.items.map((item) =>
+        normalizeLibraryItemProviderSource(item, {
+          providerId: id,
+        }),
+      );
+    },
+  };
+}
+
+export function createStaticLibraryManifestProvider({
+  displayName,
+  id,
+  manifestText,
+}: StaticLibraryManifestProviderOptions): LibraryProvider {
+  return createLibraryManifestProvider({
+    displayName,
+    id,
+    loadManifestText: () => manifestText,
+  });
+}
+
+export function createLibraryManifestObjectProvider({
+  displayName,
+  id,
+  manifest,
+}: ObjectLibraryManifestProviderOptions): LibraryProvider {
+  return {
+    displayName,
+    id,
+    async listItems() {
+      const parsedManifest = parseLibraryManifestSourceData(id, manifest);
+      return parsedManifest.items.map((item) =>
+        normalizeLibraryItemProviderSource(item, {
+          providerId: id,
+        }),
+      );
+    },
+  };
+}
+
+export function createLibraryManifestUrlProvider({
+  displayName,
+  id,
+  manifestUrl,
+  readText,
+}: HttpLibraryManifestProviderOptions): LibraryProvider {
+  return createLibraryManifestProvider({
+    displayName,
+    id,
+    loadManifestText: async () => {
+      const loader = readText ?? defaultReadText;
+      return loader(manifestUrl);
+    },
+  });
+}
+
+function parseLibraryManifestSourceText(
+  providerId: string,
+  rawManifestText: string,
+): LibraryManifest {
+  const manifest = parseLibraryManifestText(rawManifestText, `library-manifest:${providerId}`);
+
+  return normalizeManifestSourceId(manifest, providerId);
+}
+
+function parseLibraryManifestSourceData(
+  providerId: string,
+  rawManifestData: unknown,
+): LibraryManifest {
+  const manifest = parseLibraryManifest(rawManifestData, `library-manifest:${providerId}`);
+
+  return normalizeManifestSourceId(manifest, providerId);
+}
+
+function normalizeManifestSourceId(manifest: LibraryManifest, providerId: string): LibraryManifest {
+  if (manifest.source.sourceId) {
+    return manifest;
+  }
+
+  return {
+    ...manifest,
+    source: {
+      ...manifest.source,
+      sourceId: providerId,
+    },
+  };
+}
+
+async function defaultReadText(url: string): Promise<string> {
+  if (typeof globalThis.fetch !== 'function') {
+    throw new Error('fetch is not available in this environment');
+  }
+
+  const response = await globalThis.fetch(url);
+  if (!response.ok) {
+    const statusText = response.statusText ? ` ${response.statusText}` : '';
+    throw new Error(`Failed to load library manifest from ${url}: ${response.status}${statusText}`);
+  }
+
+  return response.text();
+}

package/src/runtime.ts

@@ -0,0 +1,97 @@
+import type { ChatStreamEvent, ChatTransport } from '@workbench-kit/contracts';
+import type { WorkbenchRuntimeEvent, MockWorkbenchRuntime } from '@workbench-kit/runtime';
+
+export interface RuntimeChatTransportOptions {
+  runtime: MockWorkbenchRuntime;
+}
+
+export function createChatTransportFromRuntime({
+  runtime,
+}: RuntimeChatTransportOptions): ChatTransport {
+  return {
+    cancel: () => runtime.cancel(),
+    sendMessage: async (message, options) => {
+      void options;
+      const next = runtime.sendMessage(message);
+      if (!next) return undefined;
+
+      return {
+        content: next.content,
+        createdAt: next.createdAt,
+        id: next.id,
+        label: next.label,
+        source: next.source,
+      };
+    },
+    subscribe: (listener: (event: ChatStreamEvent) => void) =>
+      runtime.subscribe((event: WorkbenchRuntimeEvent) => {
+        if (event.type === 'message') {
+          listener({
+            message: {
+              content: event.message.content,
+              createdAt: event.message.createdAt,
+              id: event.message.id,
+              label: event.message.label,
+              source: event.message.source,
+            },
+            type: 'message',
+          });
+          return;
+        }
+
+        if (event.type === 'message-delta') {
+          listener({
+            delta: event.delta,
+            message: {
+              content: event.message.content,
+              createdAt: event.message.createdAt,
+              id: event.message.id,
+              label: event.message.label,
+              source: event.message.source,
+            },
+            type: 'message-delta',
+          });
+          return;
+        }
+
+        if (event.type === 'status') {
+          listener({
+            previousStatus: event.previousStatus,
+            status: event.status,
+            type: 'status',
+          });
+          return;
+        }
+
+        if (event.patch.type === 'delete-file') {
+          listener({
+            patch: { path: event.patch.path, type: 'delete-file' },
+            type: 'workspace-patch',
+          });
+          return;
+        }
+
+        listener({
+          patch: {
+            content: event.patch.content,
+            mimeType: event.patch.mimeType,
+            path: event.patch.path,
+            source: event.patch.source,
+            type: 'write-file',
+            updatedAt: event.patch.updatedAt,
+          },
+          type: 'workspace-patch',
+        });
+      }),
+  };
+}
+
+export function emitRuntimeWorkspacePatch({
+  runtime,
+  patch,
+}: {
+  runtime: Pick<MockWorkbenchRuntime, 'emitWorkspacePatch'>;
+  patch: Parameters<MockWorkbenchRuntime['emitWorkspacePatch']>[0];
+}) {
+  runtime.emitWorkspacePatch(patch);
+}

package/src/workspace.ts

@@ -0,0 +1,126 @@
+import { normalizeWorkspacePath } from '@workbench-kit/workspace';
+import type {
+  CreateWorkspaceFileInput,
+  WriteWorkspaceFileInput,
+  WorkspaceFile,
+} from '@workbench-kit/workspace';
+import type { SaveInput, WorkspaceFileRepository } from '@workbench-kit/contracts';
+
+export interface WorkspaceFileRepositoryCallbacks {
+  createFile: (file: CreateWorkspaceFileInput) => void;
+  deleteFile: (path: string) => void;
+  saveFile: (path: string, file: WriteWorkspaceFileInput) => void;
+}
+
+export interface WorkspaceFileAdapterState {
+  getFiles: () => WorkspaceFile[];
+  files: WorkspaceFile[];
+}
+
+const cloneFile = (file: WorkspaceFile): WorkspaceFile => ({ ...file });
+
+function normalizeInputPath(path: string) {
+  return normalizeWorkspacePath(path.trim());
+}
+
+export class InMemoryWorkspaceFileRepository implements WorkspaceFileRepository {
+  private readonly files = new Map<string, WorkspaceFile>();
+
+  private readonly onCreateFile?: (file: CreateWorkspaceFileInput) => void;
+  private readonly onDeleteFile?: (path: string) => void;
+  private readonly onSaveFile?: (path: string, file: WriteWorkspaceFileInput) => void;
+
+  constructor(
+    files: readonly WorkspaceFile[] = [],
+    callbacks: {
+      onCreateFile?: (file: CreateWorkspaceFileInput) => void;
+      onDeleteFile?: (path: string) => void;
+      onSaveFile?: (path: string, file: WriteWorkspaceFileInput) => void;
+    } = {},
+  ) {
+    files.forEach((file) => {
+      const path = normalizeWorkspacePath(file.path);
+      if (!path) return;
+      this.files.set(path, { ...file, path });
+    });
+    this.onCreateFile = callbacks.onCreateFile;
+    this.onDeleteFile = callbacks.onDeleteFile;
+    this.onSaveFile = callbacks.onSaveFile;
+  }
+
+  async deleteFile(path: string): Promise<void> {
+    const normalizedPath = normalizeInputPath(path);
+    if (!normalizedPath) return;
+    if (!this.files.has(normalizedPath)) return;
+
+    this.files.delete(normalizedPath);
+    this.onDeleteFile?.(normalizedPath);
+  }
+
+  async getFile(path: string): Promise<WorkspaceFile | null> {
+    const normalizedPath = normalizeInputPath(path);
+    if (!normalizedPath) return null;
+
+    const file = this.files.get(normalizedPath);
+    return file ? { ...file } : null;
+  }
+
+  async listFiles(): Promise<readonly WorkspaceFile[]> {
+    return [...this.files.values()].map(cloneFile);
+  }
+
+  async writeFile(input: SaveInput): Promise<WorkspaceFile> {
+    const normalizedPath = normalizeInputPath(input.path);
+    if (!normalizedPath) {
+      throw new Error('Invalid workspace path.');
+    }
+
+    const current = await this.getFile(normalizedPath);
+    if (current && input.expectedUpdatedAt && current.updatedAt !== input.expectedUpdatedAt) {
+      throw new Error('Stale file version.');
+    }
+
+    const next: WorkspaceFile = {
+      content: input.content,
+      mimeType: input.mimeType ?? current?.mimeType,
+      path: normalizedPath,
+      source: input.source ?? current?.source,
+      updatedAt: input.updatedAt ?? current?.updatedAt,
+    };
+
+    this.files.set(normalizedPath, next);
+
+    if (current) {
+      this.onSaveFile?.(normalizedPath, {
+        content: input.content,
+        source: input.source,
+        updatedAt: input.updatedAt,
+      });
+    } else {
+      this.onCreateFile?.({
+        content: input.content,
+        mimeType: input.mimeType,
+        path: normalizedPath,
+        source: input.source,
+        updatedAt: input.updatedAt,
+      });
+    }
+
+    return next;
+  }
+}
+
+export function createWorkspaceFileRepository({
+  createFile,
+  deleteFile,
+  files,
+  saveFile,
+}: WorkspaceFileRepositoryCallbacks & {
+  files: WorkspaceFile[];
+}): WorkspaceFileRepository {
+  return new InMemoryWorkspaceFileRepository(files, {
+    onCreateFile: createFile,
+    onDeleteFile: deleteFile,
+    onSaveFile: (path, file) => saveFile(path, file),
+  });
+}