Lots of Bug Fixes (#55)

* Change internal git logic

* Rename git to lib

* Don't create dir if create fails

* Improve error messages

* Make linter require 'import type'

* Add deno.json and .vtignore automatically by default

* Remove useless error handling

* Remove encodeURIComponents

* Get rid of extra loadGigitnoreRules method

* Remove useless checks

* Repair git logic

* Update push test

* Improve test cases

* Fix jsdoc message

* Add rename test

* Update empty dir tests

* Fix push logic for files and dirs

* Stronger dirty check for checkout

* Add initial push

* Fix push test

* Tick version

* Clean up dirty check

* Improve type detection

* Update watch debounce

* Remove old install script

* Fix push for api bug

* Update deno lock

* Modify pagination

* Tests passing

* Format code

* Fix permissions

Author: 404Wolf

deno.json

@@ -1,7 +1,7 @@
 {
   "name": "@valtown/vt",
   "description": "The Val Town CLI",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "exports": "./vt.ts",
   "license": "MIT",
   "tasks": {
@@ -23,7 +23,7 @@
     "@std/encoding": "jsr:@std/encoding@^1.0.7",
     "@std/fs": "jsr:@std/fs@^1.0.13",
     "@std/path": "jsr:@std/path@^1.0.8",
-    "@valtown/sdk": "jsr:@valtown/sdk@^0.36.0",
+    "@valtown/sdk": "jsr:@valtown/sdk@^0.37.0",
     "~/": "./src/",
     "emphasize": "npm:emphasize@^7.0.0",
     "highlight.js": "npm:highlight.js@^11.11.1",
@@ -33,6 +33,7 @@
   },
   "compilerOptions": {
     "noUnusedLocals": true,
-    "noUnusedParameters": true
+    "noUnusedParameters": true,
+    "verbatimModuleSyntax": true
   }
 }

deno.lock

@@ -1,10 +1,11 @@
 import { Command } from "@cliffy/command";
 import ValTown from "@valtown/sdk";
-import { CheckoutResult } from "~/vt/git/checkout.ts";
-import { dirtyErrorMsg } from "~/cmd/git/utils.ts";
+import type { CheckoutResult } from "~/vt/lib/checkout.ts";
+import { dirtyErrorMsg } from "~/cmd/lib/utils.ts";
 import { doWithSpinner } from "~/cmd/utils.ts";
 import VTClient from "~/vt/vt/VTClient.ts";
 import { findVtRoot } from "~/vt/vt/utils.ts";
+import { branchIdToBranch } from "~/sdk.ts";
 
 const toListBranches = "Use \`vt branch\` to list branches.";
 
@@ -46,9 +47,20 @@ export const checkoutCmd = new Command()
         const config = await vt.getMeta().loadConfig();
 
         const statusResult = await vt.status();
-        // !branch && await vt.isDirty(cwd) means that we only do the isDirty
-        // check if the branch is not new
-        if (!force && (!branch && await vt.isDirty({ statusResult }))) {
+
+        if (
+          !force &&
+          (!branch && existingBranchName &&
+            (await vt.isDirty({ statusResult }) ||
+              await vt.isDirty({
+                statusResult: await vt.status({
+                  branchId: (await branchIdToBranch(
+                    config.projectId,
+                    existingBranchName,
+                  )).id,
+                }),
+              })))
+        ) {
           throw new Error(dirtyErrorMsg("checkout"));
         }
 

install.ts

@@ -0,0 +1,68 @@
+import { Command } from "@cliffy/command";
+import { user } from "~/sdk.ts";
+import { ALWAYS_IGNORE_PATTERNS, DEFAULT_BRANCH_NAME } from "~/consts.ts";
+import { parseProjectUri } from "~/cmd/parsing.ts";
+import VTClient from "~/vt/vt/VTClient.ts";
+import { checkDirectory } from "~/utils.ts";
+import { relative } from "@std/path";
+import * as join from "@std/path/join";
+import { doWithSpinner } from "~/cmd/utils.ts";
+
+export const cloneCmd = new Command()
+  .name("clone")
+  .description("Clone a val town project")
+  .arguments("<projectUri:string> [cloneDir:string] [branchName:string]")
+  .example(
+    "Clone with username/projectName",
+    `vt clone username/projectName`,
+  )
+  .example(
+    "Clone into the current directory",
+    `vt clone username/projectName .`,
+  )
+  .example(
+    "Clone with link",
+    `vt clone https://www.val.town/x/username/projectName`,
+  )
+  .example(
+    "Clone into a new directory",
+    `vt clone username/projectName new-directory`,
+  )
+  .action((_, projectUri: string, rootPath?: string, branchName?: string) => {
+    doWithSpinner("Cloning project...", async (spinner) => {
+      let targetDir = rootPath || Deno.cwd();
+
+      const { ownerName, projectName } = parseProjectUri(
+        projectUri,
+        user.username!,
+      );
+
+      branchName = branchName || DEFAULT_BRANCH_NAME;
+
+      // By default, if the target directory is the current working directory,
+      // then use the project name as the target directory
+      if (rootPath === undefined) {
+        targetDir = join.join(targetDir, projectName);
+      }
+
+      const vt = await VTClient.init({
+        rootPath: targetDir,
+        username: ownerName,
+        projectName,
+        branchName,
+      });
+
+      // Make sure that the directory is safe to clone into (exists, or gets
+      // created and then exists, and wasn't nonempty) deno-fmt-ignore
+      await checkDirectory(targetDir, { gitignoreRules: ALWAYS_IGNORE_PATTERNS, });
+
+      await vt.clone(targetDir);
+      await vt.addEditorFiles();
+
+      spinner.succeed(
+        `Project ${ownerName}/${projectName} cloned to "./${
+          relative(Deno.cwd(), targetDir)
+        }"`,
+      );
+    });
+  });

src/cmd/git/clone.ts

@@ -1,7 +1,5 @@
 import { Command } from "@cliffy/command";
 import { basename, join } from "@std/path";
-import { checkDirectory } from "~/utils.ts";
-import { DEFAULT_IGNORE_PATTERNS } from "~/consts.ts";
 import VTClient from "~/vt/vt/VTClient.ts";
 import { user } from "~/sdk.ts";
 import { APIError } from "@valtown/sdk";
@@ -14,6 +12,7 @@ export const createCmd = new Command()
   .option("--public", "Create as public project (default)")
   .option("--private", "Create as private project")
   .option("--unlisted", "Create as unlisted project")
+  .option("--no-editor-files", "Skip creating editor configuration files")
   .option("-d, --description <desc:string>", "Project description")
   .example(
     "Start fresh",
@@ -41,7 +40,12 @@ vt push
 vt checkout main`,
   )
   .action((
-    { public: isPublic, private: isPrivate, unlisted, description }: {
+    {
+      public: isPublic,
+      private: isPrivate,
+      unlisted,
+      description,
+    }: {
       public?: boolean;
       private?: boolean;
       unlisted?: boolean;
@@ -51,7 +55,10 @@ vt checkout main`,
     targetDir?: string,
   ) => {
     doWithSpinner("Creating project...", async (spinner) => {
-      let rootPath = targetDir || Deno.cwd();
+      let rootPath: string;
+      if (!targetDir) {
+        rootPath = join(Deno.cwd(), projectName);
+      } else rootPath = targetDir;
 
       // Check for mutually exclusive privacy flags
       const privacyFlags =
@@ -65,14 +72,6 @@ vt checkout main`,
       // Determine privacy setting (defaults to public)
       const privacy = isPrivate ? "private" : unlisted ? "unlisted" : "public";
 
-      // If no target directory specified, use project name
-      if (targetDir === undefined) rootPath = join(rootPath, projectName);
-
-      // Make sure directory is safe to create project in
-      await checkDirectory(rootPath, {
-        gitignoreRules: DEFAULT_IGNORE_PATTERNS,
-      });
-
       try {
         const vt = await VTClient.create(
           rootPath,
@@ -81,9 +80,7 @@ vt checkout main`,
           privacy,
           description,
         );
-
-        // Clone the initial project structure
-        await vt.clone(rootPath);
+        await vt.addEditorFiles();
 
         spinner.succeed(
           `Created ${privacy} project ${projectName} in ./${

src/cmd/git/branch.ts renamed to src/cmd/lib/branch.ts

@@ -1,6 +1,9 @@
-export { cloneCmd } from "./clone.ts";
-export { pullCmd } from "./pull.ts";
-export { statusCmd } from "./status.ts";
 export { branchCmd } from "./branch.ts";
+export { browseCmd } from "./browse.ts";
 export { checkoutCmd } from "./checkout.ts";
+export { cloneCmd } from "./clone.ts";
+export { createCmd } from "./create.ts";
+export { pullCmd } from "./pull.ts";
 export { pushCmd } from "./push.ts";
+export { statusCmd } from "./status.ts";
+export { watchCmd } from "./watch.ts";