@tscircuit/cli 0.1.22 → 0.1.24

package/cli/dev/DevServer.ts

@@ -9,6 +9,7 @@ import fs from "node:fs"
 import type { FileUpdatedEvent } from "lib/file-server/FileServerEvent"
 import * as chokidar from "chokidar"
 import { FilesystemTypesHandler } from "lib/dependency-analysis/FilesystemTypesHandler"
+import { pushSnippet } from "lib/shared/push-snippet"
 
 export class DevServer {
   port: number
@@ -68,6 +69,11 @@ export class DevServer {
       this.handleFileUpdatedEventFromServer.bind(this),
     )
 
+    this.eventsWatcher.on(
+      "REQUEST_TO_SAVE_SNIPPET",
+      this.saveSnippet.bind(this),
+    )
+
     this.filesystemWatcher = chokidar.watch(this.projectDir, {
       persistent: true,
       ignoreInitial: true,
@@ -159,6 +165,31 @@ circuit.add(<MyCircuit />)
     }
   }
 
+  private async saveSnippet() {
+    const postEvent = async (
+      event: "FAILED_TO_SAVE_SNIPPET" | "SNIPPET_SAVED",
+    ) =>
+      this.fsKy.post("api/events/create", {
+        json: { event_type: event },
+        throwHttpErrors: false,
+      })
+
+    await pushSnippet({
+      filePath: this.componentFilePath,
+      onExit: (e) => {
+        console.error("Failed to save snippet", e)
+        postEvent("FAILED_TO_SAVE_SNIPPET")
+      },
+      onError: (e) => {
+        console.error("Failed to save snippet", e)
+        postEvent("FAILED_TO_SAVE_SNIPPET")
+      },
+      onSuccess: () => {
+        postEvent("SNIPPET_SAVED")
+      },
+    })
+  }
+
   async stop() {
     this.httpServer?.close()
     this.eventsWatcher?.stop()

package/cli/init/register.ts

@@ -1,6 +1,53 @@
 import type { Command } from "commander"
 import * as fs from "node:fs"
 import * as path from "node:path"
+import { execSync } from "node:child_process"
+
+// Detect the package manager being used in the project
+const detectPackageManager = (): string => {
+  const userAgent = process.env.npm_config_user_agent || ""
+  if (userAgent.startsWith("yarn")) return "yarn"
+  if (userAgent.startsWith("pnpm")) return "pnpm"
+  if (userAgent.startsWith("bun")) return "bun"
+
+  if (fs.existsSync("yarn.lock")) return "yarn"
+  if (fs.existsSync("pnpm-lock.yaml")) return "pnpm"
+  if (fs.existsSync("bun.lockb")) return "bun"
+
+  return "npm" // Default to npm
+}
+
+// Generate a React-compatible tsconfig.json
+const generateTsConfig = (dir: string) => {
+  const tsconfigPath = path.join(dir, "tsconfig.json")
+  const tsconfigContent = JSON.stringify(
+    {
+      compilerOptions: {
+        target: "ES6",
+        module: "ESNext",
+        jsx: "react-jsx",
+        outDir: "dist",
+        strict: true,
+        esModuleInterop: true,
+        moduleResolution: "node",
+        skipLibCheck: true,
+        forceConsistentCasingInFileNames: true,
+        resolveJsonModule: true,
+        sourceMap: true,
+        allowSyntheticDefaultImports: true,
+        experimentalDecorators: true,
+      },
+    },
+    null,
+    2,
+  )
+  if (!fs.existsSync(tsconfigPath)) {
+    fs.writeFileSync(tsconfigPath, tsconfigContent.trimStart())
+    console.log(`Created: ${tsconfigPath}`)
+  } else {
+    console.log(`Skipped: ${tsconfigPath} already exists`)
+  }
+}
 
 export const registerInit = (program: Command) => {
   program
@@ -8,11 +55,13 @@ export const registerInit = (program: Command) => {
     .description("Initialize a new TSCircuit project in the current directory")
     .action(() => {
       const currentDir = process.cwd()
-
       const indexFilePath = path.join(currentDir, "index.tsx")
       const npmrcFilePath = path.join(currentDir, ".npmrc")
 
+      // Content for index.tsx
       const indexContent = `
+import "@tscircuit/core"
+
 export default () => (
   <board width="10mm" height="10mm">
     <resistor
@@ -32,12 +81,14 @@ export default () => (
     <trace from=".R1 > .pin1" to=".C1 > .pin1" />
   </board>
 );
-`
+`.trim()
 
+      // Content for .npmrc
       const npmrcContent = `
 @tsci:registry=https://npm.tscircuit.com
-`
+`.trim()
 
+      // Create index.tsx if it doesn't exist
       if (!fs.existsSync(indexFilePath)) {
         fs.writeFileSync(indexFilePath, indexContent.trimStart())
         console.log(`Created: ${indexFilePath}`)
@@ -45,6 +96,7 @@ export default () => (
         console.log(`Skipped: ${indexFilePath} already exists`)
       }
 
+      // Create .npmrc if it doesn't exist
       if (!fs.existsSync(npmrcFilePath)) {
         fs.writeFileSync(npmrcFilePath, npmrcContent.trimStart())
         console.log(`Created: ${npmrcFilePath}`)
@@ -52,6 +104,31 @@ export default () => (
         console.log(`Skipped: ${npmrcFilePath} already exists`)
       }
 
+      // Detect the package manager
+      const packageManager = detectPackageManager()
+      console.log(`Detected package manager: ${packageManager}`)
+
+      // Install deps using the detected package manager
+      const dependencies = "@types/react @tscircuit/core"
+      try {
+        console.log("Installing dependencies...")
+        const installCommand =
+          packageManager === "yarn"
+            ? `yarn add -D ${dependencies}`
+            : packageManager === "pnpm"
+              ? `pnpm add -D ${dependencies}`
+              : packageManager === "bun"
+                ? `bun add -D ${dependencies}`
+                : `npm install -D ${dependencies}`
+        execSync(installCommand, { stdio: "inherit" })
+        console.log("Dependencies installed successfully.")
+      } catch (error) {
+        console.error("Failed to install dependencies:", error)
+      }
+
+      // Generate tsconfig.json
+      generateTsConfig(currentDir)
+
       console.log(
         `Initialization complete. Run "tsci dev" to start developing.`,
       )

package/cli/main.ts

@@ -16,7 +16,7 @@ import { registerAuthPrintToken } from "./auth/print-token/register"
 import { registerAuthSetToken } from "./auth/set-token/register"
 import { registerPush } from "./push/register"
 
-const program = new Command()
+export const program = new Command()
 
 program
   .name("tsci")

package/cli/push/register.ts

@@ -1,9 +1,5 @@
+import { pushSnippet } from "lib/shared/push-snippet"
 import type { Command } from "commander"
-import { cliConfig } from "lib/cli-config"
-import { getKy } from "lib/registry-api/get-ky"
-import * as fs from "node:fs"
-import * as path from "node:path"
-import semver from "semver"
 
 export const registerPush = (program: Command) => {
   program
@@ -11,189 +7,11 @@ export const registerPush = (program: Command) => {
     .description("Save snippet code to Registry API")
     .argument("[file]", "Path to the snippet file")
     .action(async (filePath?: string) => {
-      const sessionToken = cliConfig.get("sessionToken")
-      if (!sessionToken) {
-        console.error("You need to log in to save snippet.")
-        process.exit(1)
-      }
-
-      let snippetFilePath: string | null = null
-      if (filePath) {
-        snippetFilePath = path.resolve(filePath)
-      } else {
-        const defaultEntrypoint = path.resolve("index.tsx")
-        if (fs.existsSync(defaultEntrypoint)) {
-          snippetFilePath = defaultEntrypoint
-          console.log("No file provided. Using 'index.tsx' as the entrypoint.")
-        } else {
-          console.error(
-            "No entrypoint found. Run 'tsci init' to bootstrap a basic project.",
-          )
-          process.exit(1)
-        }
-      }
-
-      const packageJsonPath = path.resolve(
-        path.join(path.dirname(snippetFilePath), "package.json"),
-      )
-      let packageJson: { name?: string; author?: string; version?: string } = {}
-      if (fs.existsSync(packageJsonPath)) {
-        try {
-          packageJson = JSON.parse(fs.readFileSync(packageJsonPath).toString())
-        } catch {
-          console.error("Invalid package.json provided")
-          process.exit(1)
-        }
-      }
-
-      if (!fs.existsSync(snippetFilePath)) {
-        console.error(`File not found: ${snippetFilePath}`)
-        process.exit(1)
-      }
-
-      const ky = getKy()
-      const packageName = (
-        packageJson.name ?? path.parse(snippetFilePath).name
-      ).replace(/^@/, "")
-
-      const packageAuthor =
-        packageJson.author?.split(" ")[0] ?? cliConfig.get("githubUsername")
-
-      const packageIdentifier = `${packageAuthor}/${packageName}`
-
-      let packageVersion =
-        packageJson.version ??
-        (await ky
-          .post<{
-            error?: { error_code: string }
-            package_releases?: { version: string; is_latest: boolean }[]
-          }>("package_releases/list", {
-            json: { package_name: packageIdentifier },
-          })
-          .json()
-          .then(
-            (response) =>
-              response.package_releases?.[response.package_releases.length - 1]
-                ?.version,
-          )
-          .catch((error) => {
-            console.error("Failed to retrieve latest package version:", error)
-            process.exit(1)
-          }))
-
-      if (!packageVersion) {
-        console.log("Failed to retrieve package version.")
-        process.exit(1)
-      }
-
-      const updatePackageJsonVersion = (newVersion?: string) => {
-        if (packageJson.version) {
-          try {
-            packageJson.version = newVersion ?? packageVersion
-            fs.writeFileSync(
-              packageJsonPath,
-              JSON.stringify(packageJson, null, 2),
-            )
-          } catch (error) {
-            console.error("Failed to update package.json version:", error)
-          }
-        }
-      }
-
-      const doesPackageExist = await ky
-        .post<{ error?: { error_code: string } }>("packages/get", {
-          json: { name: packageIdentifier },
-          throwHttpErrors: false,
-        })
-        .json()
-        .then(
-          (response) => !(response.error?.error_code === "package_not_found"),
-        )
-
-      if (!doesPackageExist) {
-        await ky
-          .post("packages/create", {
-            json: { name: packageIdentifier },
-            headers: { Authorization: `Bearer ${sessionToken}` },
-          })
-          .catch((error) => {
-            console.error("Error creating package:", error)
-            process.exit(1)
-          })
-      }
-
-      const doesReleaseExist = await ky
-        .post<{
-          error?: { error_code: string }
-          package_release?: { version: string }
-        }>("package_releases/get", {
-          json: {
-            package_name_with_version: `${packageIdentifier}@${packageVersion}`,
-          },
-          throwHttpErrors: false,
-        })
-        .json()
-        .then((response) => {
-          if (response.package_release?.version) {
-            packageVersion = response.package_release.version
-            updatePackageJsonVersion(response.package_release.version)
-            return true
-          }
-          return !(response.error?.error_code === "package_release_not_found")
-        })
-
-      if (doesReleaseExist) {
-        const bumpedVersion = semver.inc(packageVersion, "patch")!
-        console.log(
-          `Incrementing Package Version ${packageVersion} -> ${bumpedVersion}`,
-        )
-        packageVersion = bumpedVersion
-        updatePackageJsonVersion(packageVersion)
-      }
-
-      await ky
-        .post("package_releases/create", {
-          json: {
-            package_name_with_version: `${packageIdentifier}@${packageVersion}`,
-          },
-          throwHttpErrors: false,
-        })
-        .catch((error) => {
-          console.error("Error creating release:", error)
-          process.exit(1)
-        })
-
-      console.log("\n")
-
-      const directoryFiles = fs.readdirSync(path.dirname(snippetFilePath))
-      for (const file of directoryFiles) {
-        const fileExtension = path.extname(file).replace(".", "")
-        if (!["json", "tsx", "ts"].includes(fileExtension)) continue
-
-        const fileContent =
-          fs
-            .readFileSync(path.join(path.dirname(snippetFilePath), file))
-            .toString() ?? ""
-        await ky
-          .post("package_files/create", {
-            json: {
-              file_path: file,
-              content_text: fileContent,
-              package_name_with_version: `${packageIdentifier}@${packageVersion}`,
-            },
-            throwHttpErrors: false,
-          })
-          .then(() => {
-            console.log(`Uploaded file ${file} to the registry.`)
-          })
-          .catch((error) => {
-            console.error(`Error uploading file ${file}:`, error)
-          })
-      }
-
-      console.log(
-        `\n🎉 Successfully pushed package ${packageIdentifier}@${packageVersion} to the registry!${Bun.color("blue", "ansi")}`,
-        `https://tscircuit.com/${packageIdentifier} \x1b[0m`,
-      )
+      await pushSnippet({
+        filePath,
+        onExit: (code) => process.exit(code),
+        onError: (message) => console.error(message),
+        onSuccess: (message) => console.log(message),
+      })
     })
 }