@tscircuit/cli 0.1.21 → 0.1.23

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

@@ -14,6 +14,7 @@ import semver from "semver"
 import { registerExport } from "./export/register"
 import { registerAuthPrintToken } from "./auth/print-token/register"
 import { registerAuthSetToken } from "./auth/set-token/register"
+import { registerPush } from "./push/register"
 
 const program = new Command()
 
@@ -28,6 +29,7 @@ registerInit(program)
 
 registerDev(program)
 registerClone(program)
+registerPush(program)
 
 registerAuth(program)
 registerAuthLogin(program)

package/cli/push/register.ts

@@ -0,0 +1,199 @@
+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
+    .command("push")
+    .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`,
+      )
+    })
+}