Experimental: Create repo from IDE (#418)

- create new repos by specifying https://github.com/fjakobs/empty-repo
as the git remote
- default branch is called `ide` so it can act as label in the Repos web
UI
- the empty repo comes with a Readme explaining what's going on


https://user-images.githubusercontent.com/40952/216372784-88f60cb9-eb24-4a7a-be52-5d93f6d05c83.mov

Author: fjakobs

packages/databricks-vscode/src/cli/BricksTasks.ts

@@ -19,15 +19,16 @@ import {Loggers} from "../logger";
 import {Context, context} from "@databricks/databricks-sdk/dist/context";
 import {PackageMetaData} from "../utils/packageJsonUtils";
 
-export const TaskSyncType = {
+export const TASK_SYNC_TYPE = {
     syncFull: "sync-full",
     sync: "sync",
 } as const;
-type TaskSyncType = (typeof TaskSyncType)[keyof typeof TaskSyncType];
+
+type TaskSyncType = (typeof TASK_SYNC_TYPE)[keyof typeof TASK_SYNC_TYPE];
 
 const cliToTaskSyncType = new Map<SyncType, TaskSyncType>([
-    ["full", TaskSyncType.syncFull],
-    ["incremental", TaskSyncType.sync],
+    ["full", TASK_SYNC_TYPE.syncFull],
+    ["incremental", TASK_SYNC_TYPE.sync],
 ]);
 
 export class SyncTask extends Task {
@@ -68,7 +69,7 @@ export class SyncTask extends Task {
     static killAll() {
         window.terminals.forEach((terminal) => {
             if (
-                Object.values(TaskSyncType)
+                Object.values(TASK_SYNC_TYPE)
                     .map((e) => e as string)
                     .includes(terminal.name)
             ) {

packages/databricks-vscode/src/configuration/ConnectionCommands.ts

@@ -16,6 +16,7 @@ import {ConnectionManager} from "./ConnectionManager";
 import {UrlUtils} from "../utils";
 import {workspaceConfigs} from "../WorkspaceConfigs";
 import {WorkspaceFsCommands} from "../workspace-fs";
+import {REPO_NAME_SUFFIX} from "./SyncDestination";
 
 function formatQuickPickClusterSize(sizeInMB: number): string {
     if (sizeInMB > 1024) {
@@ -230,28 +231,66 @@ export class ConnectionCommands implements Disposable {
                     label: "Create New Sync Destination",
                     alwaysShow: true,
                     detail: workspaceConfigs.enableFilesInWorkspace
-                        ? ""
-                        : `Open Databricks in the browser and create a new Repo under /Repo/${me}`,
+                        ? `Create a new folder under /Workspace/${me}/.ide as sync destination`
+                        : `Create a new Repo under /Repo/${me} as sync destination`,
                 },
                 {
-                    label: "",
+                    label: "Sync Destinations",
                     kind: QuickPickItemKind.Separator,
                 },
             ];
 
             const input = window.createQuickPick();
             input.busy = true;
-            input.items = children;
             input.show();
-            children.push(
-                ...((await rootDir?.children) ?? []).map((entity) => {
-                    return {
-                        label: entity.basename,
-                        detail: entity.path,
-                        path: entity.path,
-                    };
-                })
-            );
+            input.items = children;
+            if (workspaceConfigs.enableFilesInWorkspace) {
+                children.push(
+                    ...((await rootDir?.children) ?? []).map((entity) => {
+                        return {
+                            label: entity.basename,
+                            detail: entity.path,
+                            path: entity.path,
+                        };
+                    })
+                );
+            } else {
+                const repos = (await rootDir?.children) ?? [];
+
+                children.push(
+                    ...repos
+                        .filter((entity) => {
+                            return entity.basename.endsWith(REPO_NAME_SUFFIX);
+                        })
+                        .map((entity) => {
+                            return {
+                                label: entity.basename.slice(
+                                    0,
+                                    -REPO_NAME_SUFFIX.length
+                                ),
+                                detail: entity.path,
+                                path: entity.path,
+                            };
+                        })
+                );
+                children.push(
+                    {
+                        label: "Repos",
+                        kind: QuickPickItemKind.Separator,
+                    },
+                    ...repos
+                        .filter((entity) => {
+                            return !entity.basename.endsWith(REPO_NAME_SUFFIX);
+                        })
+                        .map((entity) => {
+                            return {
+                                label: entity.basename,
+                                detail: entity.path,
+                                path: entity.path,
+                            };
+                        })
+                );
+            }
             input.items = children;
             input.busy = false;
 
@@ -267,19 +306,11 @@ export class ConnectionCommands implements Disposable {
                             );
                             return;
                         }
-                        if (!workspaceConfigs.enableFilesInWorkspace) {
-                            UrlUtils.openExternal(
-                                (await rootDir?.url) ??
-                                    (
-                                        await this.connectionManager
-                                            .workspaceClient?.apiClient?.host
-                                    )?.href ??
-                                    ""
-                            );
-                            return;
-                        }
                         const created = await this.wsfsCommands.createFolder(
-                            rootDir
+                            rootDir,
+                            workspaceConfigs.enableFilesInWorkspace
+                                ? "Folder"
+                                : "Repo"
                         );
                         if (created === undefined) {
                             return;

packages/databricks-vscode/src/configuration/SyncDestination.ts

@@ -9,6 +9,7 @@ import {Uri} from "vscode";
 import {ConnectionManager} from "./ConnectionManager";
 
 type SyncDestinationType = "workspace" | "repo";
+export const REPO_NAME_SUFFIX = ".ide";
 
 /**
  * Either Databricks repo or workspace that acts as a sync target for the current workspace.
@@ -120,7 +121,12 @@ export class SyncDestination {
     }
 
     get name(): string {
-        return path.basename(this.wsfsDirPath.path);
+        const base = path.basename(this.wsfsDirPath.path);
+        if (base.endsWith(REPO_NAME_SUFFIX)) {
+            return base.slice(0, -REPO_NAME_SUFFIX.length);
+        } else {
+            return base;
+        }
     }
 
     get vscodeWorkspacePathName(): string {

packages/databricks-vscode/src/sync/CodeSynchronizer.ts

@@ -1,5 +1,5 @@
 import {Disposable, Event, EventEmitter, TaskExecution, tasks} from "vscode";
-import {SyncTask, TaskSyncType} from "../cli/BricksTasks";
+import {SyncTask, TASK_SYNC_TYPE} from "../cli/BricksTasks";
 import {CliWrapper} from "../cli/CliWrapper";
 import {ConnectionManager} from "../configuration/ConnectionManager";
 import {PackageMetaData} from "../utils/packageJsonUtils";
@@ -40,7 +40,7 @@ export class CodeSynchronizer implements Disposable {
                 const {type, task} = e.execution.task.definition;
                 if (
                     type === "databricks" &&
-                    Object.values(TaskSyncType).includes(task)
+                    Object.values(TASK_SYNC_TYPE).includes(task)
                 ) {
                     this.currentTaskExecution = e.execution;
                     this._onDidChangeStateEmitter.fire(this.state);
@@ -50,7 +50,7 @@ export class CodeSynchronizer implements Disposable {
                 const {type, task} = e.execution.task.definition;
                 if (
                     type === "databricks" &&
-                    Object.values(TaskSyncType).includes(task)
+                    Object.values(TASK_SYNC_TYPE).includes(task)
                 ) {
                     this.currentTaskExecution = undefined;
                     this._onDidChangeStateEmitter.fire(this.state);

packages/databricks-vscode/src/workspace-fs/WorkspaceFsCommands.ts

@@ -3,6 +3,7 @@ import {context, Context} from "@databricks/databricks-sdk/dist/context";
 import {withLogContext} from "@databricks/databricks-sdk/dist/logging";
 import {Disposable, Uri, window} from "vscode";
 import {ConnectionManager} from "../configuration/ConnectionManager";
+import {REPO_NAME_SUFFIX} from "../configuration/SyncDestination";
 import {Loggers} from "../logger";
 import {createDirWizard} from "./createDirectoryWizard";
 import {WorkspaceFsDataProvider} from "./WorkspaceFsDataProvider";
@@ -21,14 +22,21 @@ export class WorkspaceFsCommands implements Disposable {
             Uri.from({scheme: "wsfs", path: element.path})
         );
     }
+
     @withLogContext(Loggers.Extension)
-    async createFolder(element?: WorkspaceFsEntity, @context ctx?: Context) {
+    async createFolder(
+        element?: WorkspaceFsEntity,
+        type: "Repo" | "Folder" = "Folder",
+        @context ctx?: Context
+    ) {
         const rootPath =
             element?.path ??
             this._connectionManager.databricksWorkspace?.currentFsRoot.path;
 
         if (!this._connectionManager.workspaceClient) {
-            window.showErrorMessage(`Login to create a new directory`);
+            window.showErrorMessage(
+                `Please login first to create a new directory`
+            );
             return;
         }
 
@@ -55,16 +63,51 @@ export class WorkspaceFsCommands implements Disposable {
             return;
         }
 
-        const created = await createDirWizard(root, this._workspaceFolder);
+        const inputPath = await createDirWizard(
+            this._workspaceFolder,
+            type === "Repo" ? "Repo Name" : "Directory Name"
+        );
+        let created: WorkspaceFsEntity | undefined;
+
+        if (inputPath !== undefined) {
+            if (type === "Repo") {
+                created = await this.createRepo(
+                    rootPath + "/" + inputPath + REPO_NAME_SUFFIX
+                );
+            } else {
+                created = await root.mkdir(inputPath);
+            }
+            if (created === undefined) {
+                window.showErrorMessage(`Can't create directory ${inputPath}`);
+            }
+        }
+
         if (created) {
             this._workspaceFsDataProvider.refresh();
             return created;
         }
     }
 
+    private async createRepo(repoPath: string) {
+        const wsClient = this._connectionManager.workspaceClient;
+        if (!wsClient) {
+            window.showErrorMessage(`Please login first to create a new repo`);
+            return;
+        }
+
+        await wsClient.repos.create({
+            path: repoPath,
+            provider: "github",
+            url: "https://github.com/databricks/databricks-empty-ide-project",
+        });
+
+        return await WorkspaceFsEntity.fromPath(wsClient, repoPath);
+    }
+
     async refresh() {
         this._workspaceFsDataProvider.refresh();
     }
+
     dispose() {
         this.disposables.forEach((i) => i.dispose());
     }

packages/databricks-vscode/src/workspace-fs/createDirectoryWizard.ts

@@ -1,28 +1,21 @@
 import {Uri, window} from "vscode";
-import {WorkspaceFsDir} from "@databricks/databricks-sdk";
 import path from "path";
 
 export async function createDirWizard(
-    root: WorkspaceFsDir,
-    workspaceFolder: Uri
-) {
-    const inputPath = await window.showInputBox({
-        title: `Create new directory`,
+    workspaceFolder: Uri,
+    title: string
+): Promise<string | undefined> {
+    return await window.showInputBox({
+        title: title,
         placeHolder: path.basename(workspaceFolder.fsPath),
         value: path.basename(workspaceFolder.fsPath),
         validateInput: (input) => {
-            const childPath = root.getAbsoluteChildPath(input);
-            if (childPath === undefined || childPath === root.path) {
-                return `The path must be a child of ${root.path}`;
+            if (input === "") {
+                return "Please enter a name";
+            }
+            if (input.includes("/")) {
+                return "Invalid name: Folders cannot contain '/'";
             }
         },
     });
-
-    if (inputPath !== undefined) {
-        const created = await root.mkdir(inputPath);
-        if (created === undefined) {
-            window.showErrorMessage(`Can't create directory ${inputPath}`);
-        }
-        return created;
-    }
 }