@aprovan/patchwork-vscode 0.1.0

package/src/providers/PatchworkFileSystemProvider.ts

@@ -0,0 +1,205 @@
+import * as vscode from "vscode";
+import type { VirtualFile, VirtualProject } from "@aprovan/patchwork-compiler";
+
+interface ParsedPatchworkUri {
+  projectId: string;
+  path: string;
+}
+
+export class PatchworkFileSystemProvider implements vscode.FileSystemProvider {
+  private readonly onDidChangeFileEmitter = new vscode.EventEmitter<
+    vscode.FileChangeEvent[]
+  >();
+  readonly onDidChangeFile = this.onDidChangeFileEmitter.event;
+
+  private readonly projects = new Map<string, VirtualProject>();
+
+  setProject(id: string, project: VirtualProject): void {
+    this.projects.set(id, project);
+    this.onDidChangeFileEmitter.fire([]);
+  }
+
+  clearProjects(): void {
+    this.projects.clear();
+    this.onDidChangeFileEmitter.fire([]);
+  }
+
+  readFile(uri: vscode.Uri): Uint8Array {
+    const { projectId, path } = this.parseUri(uri);
+    const project = this.getProject(projectId);
+    const file = project.files.get(path);
+    if (!file) throw vscode.FileSystemError.FileNotFound(uri);
+    return this.encodeFileContent(file);
+  }
+
+  writeFile(
+    uri: vscode.Uri,
+    content: Uint8Array,
+    options: { create: boolean; overwrite: boolean },
+  ): void {
+    const { projectId, path } = this.parseUri(uri);
+    const project = this.getProject(projectId);
+    const exists = project.files.has(path);
+    if (!exists && !options.create) {
+      throw vscode.FileSystemError.FileNotFound(uri);
+    }
+    if (exists && !options.overwrite) {
+      throw vscode.FileSystemError.FileExists(uri);
+    }
+
+    const file = this.decodeFileContent(path, content);
+    project.files.set(path, file);
+    this.onDidChangeFileEmitter.fire([
+      {
+        type: exists
+          ? vscode.FileChangeType.Changed
+          : vscode.FileChangeType.Created,
+        uri,
+      },
+    ]);
+  }
+
+  stat(uri: vscode.Uri): vscode.FileStat {
+    const { projectId, path } = this.parseUri(uri);
+    const project = this.getProject(projectId);
+
+    if (!path) {
+      return {
+        type: vscode.FileType.Directory,
+        ctime: 0,
+        mtime: 0,
+        size: 0,
+      };
+    }
+
+    const file = project.files.get(path);
+    if (file) {
+      return {
+        type: vscode.FileType.File,
+        ctime: 0,
+        mtime: 0,
+        size: this.encodeFileContent(file).byteLength,
+      };
+    }
+
+    if (this.hasDirectory(project, path)) {
+      return {
+        type: vscode.FileType.Directory,
+        ctime: 0,
+        mtime: 0,
+        size: 0,
+      };
+    }
+
+    throw vscode.FileSystemError.FileNotFound(uri);
+  }
+
+  readDirectory(uri: vscode.Uri): [string, vscode.FileType][] {
+    const { projectId, path } = this.parseUri(uri);
+    const project = this.getProject(projectId);
+    return this.listDirectoryEntries(project, path);
+  }
+
+  createDirectory(): void {
+    throw vscode.FileSystemError.NoPermissions(
+      "Patchwork file system is read/write via file edits only.",
+    );
+  }
+
+  delete(): void {
+    throw vscode.FileSystemError.NoPermissions(
+      "Patchwork file deletion is not implemented yet.",
+    );
+  }
+
+  rename(): void {
+    throw vscode.FileSystemError.NoPermissions(
+      "Patchwork file rename is not implemented yet.",
+    );
+  }
+
+  watch(): vscode.Disposable {
+    return new vscode.Disposable(() => undefined);
+  }
+
+  private parseUri(uri: vscode.Uri): ParsedPatchworkUri {
+    if (uri.scheme !== "patchwork") {
+      throw vscode.FileSystemError.Unavailable(
+        "Unsupported URI scheme for Patchwork provider.",
+      );
+    }
+    const projectId = uri.authority;
+    if (!projectId) {
+      throw vscode.FileSystemError.FileNotFound(uri);
+    }
+    const path = uri.path.replace(/^\/+/, "");
+    return { projectId, path };
+  }
+
+  private getProject(projectId: string): VirtualProject {
+    const project = this.projects.get(projectId);
+    if (!project) {
+      throw vscode.FileSystemError.FileNotFound(
+        vscode.Uri.parse(`patchwork://${projectId}`),
+      );
+    }
+    return project;
+  }
+
+  private encodeFileContent(file: VirtualFile): Uint8Array {
+    if (file.encoding === "base64") {
+      return Buffer.from(file.content, "base64");
+    }
+    return Buffer.from(file.content, "utf8");
+  }
+
+  private decodeFileContent(path: string, content: Uint8Array): VirtualFile {
+    const hasNull = content.some((byte) => byte === 0);
+    if (hasNull) {
+      return {
+        path,
+        content: Buffer.from(content).toString("base64"),
+        encoding: "base64",
+      };
+    }
+
+    return {
+      path,
+      content: Buffer.from(content).toString("utf8"),
+      encoding: "utf8",
+    };
+  }
+
+  private hasDirectory(project: VirtualProject, path: string): boolean {
+    const prefix = path.endsWith("/") ? path : `${path}/`;
+    for (const filePath of project.files.keys()) {
+      if (filePath.startsWith(prefix)) return true;
+    }
+    return false;
+  }
+
+  private listDirectoryEntries(
+    project: VirtualProject,
+    path: string,
+  ): [string, vscode.FileType][] {
+    const prefix = path ? `${path.replace(/\/+$/, "")}/` : "";
+    const entries = new Map<string, vscode.FileType>();
+
+    for (const filePath of project.files.keys()) {
+      if (!filePath.startsWith(prefix)) continue;
+      const remainder = filePath.slice(prefix.length);
+      if (!remainder) continue;
+      const [segment, ...rest] = remainder.split("/");
+      if (!segment) continue;
+      if (rest.length === 0) {
+        entries.set(segment, vscode.FileType.File);
+      } else if (!entries.has(segment)) {
+        entries.set(segment, vscode.FileType.Directory);
+      }
+    }
+
+    return Array.from(entries.entries()).sort((a, b) =>
+      a[0].localeCompare(b[0]),
+    );
+  }
+}

package/src/providers/PatchworkTreeProvider.ts

@@ -0,0 +1,177 @@
+import * as vscode from "vscode";
+import type { VirtualProject } from "@aprovan/patchwork-compiler";
+
+type TreeNodeKind = "empty" | "project" | "folder" | "file";
+
+interface PatchworkTreeNode {
+  label: string;
+  kind: TreeNodeKind;
+  projectId?: string;
+  path?: string;
+  children?: PatchworkTreeNode[];
+}
+
+export class PatchworkTreeItem extends vscode.TreeItem {
+  readonly kind: TreeNodeKind;
+  readonly projectId?: string;
+  readonly path?: string;
+  readonly children?: PatchworkTreeItem[];
+
+  constructor(
+    node: PatchworkTreeNode,
+    collapsibleState: vscode.TreeItemCollapsibleState,
+  ) {
+    super(node.label, collapsibleState);
+    this.kind = node.kind;
+    this.projectId = node.projectId;
+    this.path = node.path;
+    this.children = node.children?.map(
+      (child) =>
+        new PatchworkTreeItem(
+          child,
+          child.children && child.children.length > 0
+            ? vscode.TreeItemCollapsibleState.Collapsed
+            : vscode.TreeItemCollapsibleState.None,
+        ),
+    );
+
+    if (this.kind === "folder" || this.kind === "project") {
+      this.iconPath = vscode.ThemeIcon.Folder;
+    } else if (this.kind === "file") {
+      this.iconPath = vscode.ThemeIcon.File;
+      if (this.projectId && this.path) {
+        this.command = {
+          command: "patchwork.openFile",
+          title: "Open Patchwork File",
+          arguments: [this.projectId, this.path],
+        };
+        this.tooltip = this.path;
+      }
+    }
+  }
+}
+
+export class PatchworkTreeProvider
+  implements vscode.TreeDataProvider<PatchworkTreeItem>
+{
+  private readonly onDidChangeTreeDataEmitter = new vscode.EventEmitter<
+    PatchworkTreeItem | undefined
+  >();
+  readonly onDidChangeTreeData = this.onDidChangeTreeDataEmitter.event;
+
+  private readonly projects = new Map<string, VirtualProject>();
+
+  setProject(id: string, project: VirtualProject): void {
+    this.projects.set(id, project);
+    this.onDidChangeTreeDataEmitter.fire(undefined);
+  }
+
+  clearProjects(): void {
+    this.projects.clear();
+    this.onDidChangeTreeDataEmitter.fire(undefined);
+  }
+
+  getTreeItem(element: PatchworkTreeItem): vscode.TreeItem {
+    return element;
+  }
+
+  getChildren(element?: PatchworkTreeItem): Thenable<PatchworkTreeItem[]> {
+    if (!element) {
+      if (this.projects.size === 0) {
+        return Promise.resolve([
+          new PatchworkTreeItem(
+            { label: "No Patchwork projects", kind: "empty" },
+            vscode.TreeItemCollapsibleState.None,
+          ),
+        ]);
+      }
+
+      const projectItems = Array.from(this.projects.values())
+        .sort((a, b) => a.id.localeCompare(b.id))
+        .map(
+          (project) =>
+            new PatchworkTreeItem(
+              {
+                label: project.id,
+                kind: "project",
+                projectId: project.id,
+                children: this.buildProjectNodes(project),
+              },
+              vscode.TreeItemCollapsibleState.Collapsed,
+            ),
+        );
+
+      return Promise.resolve(projectItems);
+    }
+
+    if (element.children) {
+      return Promise.resolve(element.children);
+    }
+
+    return Promise.resolve([]);
+  }
+
+  private buildProjectNodes(project: VirtualProject): PatchworkTreeNode[] {
+    type InternalNode = {
+      label: string;
+      kind: TreeNodeKind;
+      projectId: string;
+      path: string;
+      children: Map<string, InternalNode>;
+    };
+
+    const root: InternalNode = {
+      label: project.id,
+      kind: "project",
+      projectId: project.id,
+      path: "",
+      children: new Map(),
+    };
+
+    for (const [path] of project.files) {
+      const parts = path.split("/").filter(Boolean);
+      let current = root;
+      let currentPath = "";
+
+      for (let index = 0; index < parts.length; index += 1) {
+        const part = parts[index];
+        const isFile = index === parts.length - 1;
+        currentPath = currentPath ? `${currentPath}/${part}` : part;
+
+        if (!current.children.has(part)) {
+          current.children.set(part, {
+            label: part,
+            kind: isFile ? "file" : "folder",
+            projectId: project.id,
+            path: currentPath,
+            children: new Map(),
+          });
+        }
+
+        const next = current.children.get(part);
+        if (next) current = next;
+      }
+    }
+
+    const collectChildren = (
+      nodeMap: Map<string, InternalNode>,
+    ): PatchworkTreeNode[] => {
+      const nodes = Array.from(nodeMap.values());
+      return nodes
+        .sort((a, b) => {
+          if (a.kind !== b.kind) return a.kind === "folder" ? -1 : 1;
+          return a.label.localeCompare(b.label);
+        })
+        .map((node) => ({
+          label: node.label,
+          kind: node.kind,
+          projectId: node.projectId,
+          path: node.path,
+          children:
+            node.kind === "file" ? undefined : collectChildren(node.children),
+        }));
+    };
+
+    return collectChildren(root.children);
+  }
+}