@tscircuit/cli 0.0.2

package/lib/cmd-fns/soupify.ts

@@ -0,0 +1,27 @@
+import { AppContext } from "../util/app-context"
+import { z } from "zod"
+import * as Path from "path"
+import { unlink } from "node:fs/promises"
+import { soupify } from "lib/soupify"
+import { writeFileSync } from "fs"
+
+export const soupifyCmd = async (ctx: AppContext, args: any) => {
+  const params = z
+    .object({
+      file: z.string(),
+      export: z.string().optional(),
+      output: z.string().optional(),
+    })
+    .parse(args)
+
+  const soup = await soupify({
+    filePath: params.file,
+    exportName: params.export,
+  })
+
+  if (params.output) {
+    await writeFileSync(params.output, JSON.stringify(soup, null, 2))
+  } else {
+    console.log(JSON.stringify(soup, null, 2))
+  }
+}

package/lib/get-program.ts

@@ -0,0 +1,191 @@
+import { Command } from "commander"
+import packageJson from "../package.json"
+import { AppContext } from "./util/app-context"
+import * as CMDFN from "lib/cmd-fns"
+
+// | Endpoint                              | Description                  |
+// | ------------------------------------- | ---------------------------- |
+// | /packages/search         | Search for packages          |
+// | /packages/list           | List packages with a filter  |
+// | /packages/get            | Get a package by id or name  |
+// | /packages/create         | Create a new package         |
+// | /package_releases/list   | List package releases        |
+// | /package_releases/get    | Get a package release by id  |
+// | /package_releases/create | Create a new package release |
+// | /package_files/list      | List package files           |
+// | /package_files/get       | Get a package file by id     |
+// | /package_files/download  | Download a package file      |
+// | /package_files/create    | Create a new package file    |
+// | /package_examples/list   | List package examples        |
+// | /package_examples/get    | Get a package example by id  |
+// | /package_examples/create | Create a new package example |
+
+export const getProgram = (ctx: AppContext) => {
+  const cmd = new Command("tsci")
+
+  cmd.version(packageJson.version)
+
+  const authCmd = cmd.command("auth")
+  authCmd.command("login").action((args) => CMDFN.authLogin(ctx, args))
+  authCmd.command("logout").action((args) => CMDFN.authLogout(ctx, args))
+
+  const configCmd = cmd.command("config")
+
+  configCmd
+    .command("reveal-location")
+    .action((args) => CMDFN.configRevealLocation(ctx, args))
+  configCmd
+    .command("set-registry")
+    .requiredOption("--server <server>", "Registry URL")
+    .action((args) => CMDFN.configSetRegistry(ctx, args))
+  configCmd
+    .command("set-session")
+    .requiredOption("--session-token <session_token>", "Session Token")
+    .action((args) => CMDFN.configSetSession(ctx, args))
+  configCmd
+    .command("set-log-requests")
+    .requiredOption("--log-requests", "Should log requests to registry")
+    .action((args) => CMDFN.configSetLogRequests(ctx, args))
+  configCmd
+    .command("print-config")
+    .action((args) => CMDFN.configPrintConfig(ctx, args))
+
+  const authSessionsCmd = authCmd.command("sessions")
+
+  authSessionsCmd
+    .command("create")
+    .action((args) => CMDFN.authSessionsCreate(ctx, args))
+  authSessionsCmd
+    .command("list")
+    .action((args) => CMDFN.authSessionsList(ctx, args))
+  authSessionsCmd
+    .command("get")
+    .action((args) => CMDFN.authSessionsGet(ctx, args))
+
+  const packagesCmd = cmd.command("packages")
+
+  packagesCmd.command("list").action((args) => CMDFN.packagesList(ctx, args))
+  packagesCmd
+    .command("get")
+    .option("--package-id <package_id>", "Package Id")
+    .option("--name <name>", "Package name")
+    .action((args) => CMDFN.packagesGet(ctx, args))
+  packagesCmd
+    .command("create")
+    .requiredOption("--name <name>", "Package name")
+    .option("--author-id <author_account_id>", "Author Id")
+    .option("--description <description>", "Package description")
+    .action((args) => CMDFN.packagesCreate(ctx, args))
+
+  const packageReleases = cmd.command("package_releases")
+
+  packageReleases
+    .command("list")
+    .requiredOption("--package-name <package_name>", "Package name")
+    .option("--verbose", "Verbose objects (includes uuids)")
+    .action((args) => CMDFN.packageReleasesList(ctx, args))
+  packageReleases
+    .command("get")
+    .action((args) => CMDFN.packageReleasesGet(ctx, args))
+  packageReleases
+    .command("create")
+    .option(
+      "-p, --package-name-with-version <package_name_with_version>",
+      "Package name and version"
+    )
+    .option("--package-name <package_name>", "Package name")
+    .option("--release-version <release_version>", "Version to publish")
+    .action((args) => CMDFN.packageReleasesCreate(ctx, args))
+
+  const packageFiles = cmd.command("package_files")
+
+  packageFiles
+    .command("list")
+    .option(
+      "--package-name-with-version <package_name_with_version>",
+      "Package name with version"
+    )
+    .option(
+      "--package-name <package_name>",
+      "Package name (use latest version)"
+    )
+    .option("--package-release-id <package_release_id>", "Package Release Id")
+    .action((args) => CMDFN.packageFilesList(ctx, args))
+  packageFiles.command("get").action((args) => CMDFN.packageFilesGet(ctx, args))
+  packageFiles
+    .command("download")
+    .requiredOption(
+      "--package-name-with-version <package_name_with_version>",
+      "Package name and version"
+    )
+    .requiredOption("--remote-file-path <remote_file_path>", "Remote file path")
+    .option(
+      "--output <output>",
+      "Output file path (optional), prints to stdout if not provided"
+    )
+    .action((args) => CMDFN.packageFilesDownload(ctx, args))
+  packageFiles
+    .command("create")
+    .option(
+      "-p, --package-release-id <package_release_id>",
+      "Package Release Id"
+    )
+    .option(
+      "--package-name-with-version <package_name_with_version>",
+      "Package name with version e.g. @tscircuit/arduino@1.2.3"
+    )
+    .requiredOption("--file <file>", "File to upload")
+    .action((args) => CMDFN.packageFilesCreate(ctx, args))
+
+  packageFiles
+    .command("upload-directory")
+    .requiredOption("--directory <directory>", "Directory to upload")
+    .action((args) => CMDFN.packageFilesUploadDirectory(ctx, args))
+
+  const packageExamples = cmd.command("package_examples")
+
+  packageExamples
+    .command("list")
+    .requiredOption("--package-name-with-version <package_name_with_version>")
+    .action((args) => CMDFN.packageExamplesList(ctx, args))
+  packageExamples
+    .command("get")
+    .requiredOption("--package-example-id <package_example_id>")
+    .action((args) => CMDFN.packageExamplesGet(ctx, args))
+  packageExamples
+    .command("create")
+    .requiredOption("--package-name-with-version <package_name_with_version>")
+    .requiredOption("--file <file>")
+    .option("--export <export>", "Name of export to soupify")
+    .action((args) => CMDFN.packageExamplesCreate(ctx, args))
+
+  cmd.command("publish").action((args) => CMDFN.publish(ctx, args))
+
+  cmd
+    .command("version")
+    .action(() => console.log(`tsci v${packageJson.version}`))
+
+  cmd.command("login").action((args) => CMDFN.authLogin(ctx, args))
+  cmd.command("logout").action((args) => CMDFN.authLogout(ctx, args))
+
+  cmd
+    .command("soupify")
+    .requiredOption("--file <file>", "Input example files")
+    .option(
+      "--export <export_name>",
+      "Name of export to soupify, if not specified, soupify the default/only export"
+    )
+    .action((args) => CMDFN.soupify(ctx, args))
+
+  cmd
+    .command("dev")
+    .option("--cwd <cwd>", "Current working directory")
+    .option("--port <port>", "Port to run dev server on")
+    .action((args) => CMDFN.dev(ctx, args))
+
+  cmd.command("add").action((args) => {})
+  cmd.command("remove").action((args) => {})
+  cmd.command("install").action((args) => {})
+
+  return cmd
+}

package/lib/param-handlers/index.ts

@@ -0,0 +1,16 @@
+import { interactForLocalDirectory } from "./interact-for-local-directory"
+import { interactForLocalFile } from "./interact-for-local-file"
+import { interactForPackageExampleId } from "./interact-for-package-example-id"
+import { interactForPackageName } from "./interact-for-package-name"
+import { interactForPackageNameWithVersion } from "./interact-for-package-name-with-version"
+import { interactForPackageReleaseId } from "./interact-for-package-release-id"
+import { ParamHandler } from "./param-handler-type"
+
+export const PARAM_HANDLERS_BY_PARAM_NAME: Record<string, ParamHandler> = {
+  file: interactForLocalFile,
+  cwd: interactForLocalDirectory,
+  package_release_id: interactForPackageReleaseId,
+  package_name: interactForPackageName,
+  package_name_with_version: interactForPackageNameWithVersion,
+  package_example_id: interactForPackageExampleId,
+}

package/lib/param-handlers/interact-for-local-directory.ts

@@ -0,0 +1,58 @@
+import { ParamHandler } from "./param-handler-type"
+import * as fs from "fs/promises"
+
+export const interactForLocalDirectory: ParamHandler = async ({ prompts }) => {
+  const { selectionMode } = await prompts({
+    type: "select",
+    name: "selectionMode",
+    message: "Select a directory",
+    choices: [
+      { title: "Manually Enter Path", value: "manual" },
+      { title: "Browse for Directory", value: "browse" },
+    ],
+  })
+
+  if (selectionMode === "manual") {
+    const { manualPath } = await prompts({
+      type: "text",
+      name: "manualPath",
+      message: "Enter the path to the directory",
+    })
+    return manualPath
+  }
+
+  let currentDirectory = "."
+  while (true) {
+    const files = await fs.readdir(currentDirectory)
+    const dirChoices = files
+      .filter((d) => !d.includes("."))
+      .map((file) => ({ title: file, value: file }))
+    const { selectedDir } = await prompts({
+      type: "autocomplete",
+      name: "selectedDir",
+      message: "Select a directory",
+      initial: "__select__",
+      choices: [
+        { title: ".. (Go Up)", value: ".." },
+        { title: `["${currentDirectory}"]`, value: "__select__" },
+        ...dirChoices,
+      ],
+    })
+    if (selectedDir === "..") {
+      // Go up one directory
+      const lastIndex = currentDirectory.lastIndexOf("/")
+      currentDirectory = currentDirectory.substring(0, lastIndex)
+    } else if (selectedDir === "__select__") {
+      return currentDirectory
+    } else {
+      // Check if selectedFile is a file or directory
+      const stats = await fs.stat(`${currentDirectory}/${selectedDir}`)
+      if (stats.isFile()) {
+        throw new Error("Selected file is a file, not a directory")
+      } else {
+        // Go into the selected directory
+        currentDirectory = `${currentDirectory}/${selectedDir}`
+      }
+    }
+  }
+}

package/lib/param-handlers/interact-for-local-file.ts

@@ -0,0 +1,59 @@
+import { ParamHandler } from "./param-handler-type"
+import * as fs from "fs/promises"
+
+// Use prompts to allow searching for a file
+// 1. Show a prompt with two options
+//    - "Manually Enter Path"
+//    - "Browse for File"
+// 2. If Browse for File is selected, show all the files in the current
+//    directory with the "autocomplete" prompts type, then allow the user
+//    to select a file or directory
+export const interactForLocalFile: ParamHandler = async ({ prompts }) => {
+  const { selectionMode } = await prompts({
+    type: "select",
+    name: "selectionMode",
+    message: "Select a file",
+    choices: [
+      { title: "Manually Enter Path", value: "manual" },
+      { title: "Browse for File", value: "browse" },
+    ],
+  })
+
+  if (selectionMode === "manual") {
+    const { manualPath } = await prompts({
+      type: "text",
+      name: "manualPath",
+      message: "Enter the path to the file",
+    })
+    return manualPath
+  }
+
+  let currentDirectory = "."
+  while (true) {
+    const files = await fs.readdir(currentDirectory)
+    const { selectedFile } = await prompts({
+      type: "autocomplete",
+      name: "selectedFile",
+      message: "Select a file or directory",
+      choices: [
+        { title: ".. (Go Up)", value: ".." },
+        ...files.map((file) => ({ title: file, value: file })),
+      ],
+    })
+    if (selectedFile === "..") {
+      // Go up one directory
+      const lastIndex = currentDirectory.lastIndexOf("/")
+      currentDirectory = currentDirectory.substring(0, lastIndex)
+    } else {
+      // Check if selectedFile is a file or directory
+      const stats = await fs.stat(`${currentDirectory}/${selectedFile}`)
+      if (stats.isFile()) {
+        // Break out of the loop and return the selected file
+        return `${currentDirectory}/${selectedFile}`
+      } else {
+        // Go into the selected directory
+        currentDirectory = `${currentDirectory}/${selectedFile}`
+      }
+    }
+  }
+}

package/lib/param-handlers/interact-for-package-example-id.ts

@@ -0,0 +1,25 @@
+import { interactForPackageReleaseId } from "./interact-for-package-release-id"
+import { ParamHandler } from "./param-handler-type"
+
+export const interactForPackageExampleId: ParamHandler = async (params) => {
+  const { prompts, ctx } = params
+  const package_release_id = await interactForPackageReleaseId(params)
+
+  const package_examples = await ctx.axios
+    .post("/package_examples/list", {
+      package_release_id,
+    })
+    .then((r) => r.data.package_examples)
+
+  const { package_example_id } = await prompts({
+    type: "autocomplete",
+    name: "package_example_id",
+    message: "Select a package example",
+    choices: package_examples.map((p: any) => ({
+      title: `${p.file_path} (${p.export_name})`,
+      value: p.package_example_id,
+    })),
+  })
+
+  return package_example_id
+}

package/lib/param-handlers/interact-for-package-name-with-version.ts

@@ -0,0 +1,63 @@
+import { ParamHandler } from "./param-handler-type"
+
+export const interactForPackageNameWithVersion: ParamHandler = async ({
+  prompts,
+  ctx,
+}) => {
+  // Find all package names by this user
+  const myPackages: Array<{ name: string; latest_version: string }> =
+    await ctx.axios
+      .post("/packages/list", {
+        is_writable: true,
+      })
+      .then((r) => r.data.packages)
+
+  // Autocomplete prompts with all packages, first option is "Enter Manually"
+  const { selectedPackage } = await prompts({
+    type: "autocomplete",
+    name: "selectedPackage",
+    message: "Select a package",
+    choices: [
+      {
+        title: "Enter Manually",
+        value: null,
+      },
+      ...myPackages.flatMap((p) => [
+        {
+          title: `${p.name}@${p.latest_version}`,
+          value: `${p.name}@${p.latest_version}`,
+        },
+        {
+          title: `${p.name}@...`,
+          value: `${p.name}@...`,
+        },
+      ]),
+    ],
+  })
+
+  if (selectedPackage.endsWith("@...")) {
+    // TODO Poll for all versions available
+
+    const { version } = await prompts({
+      type: "text",
+      name: "version",
+      message: "Enter the version",
+    })
+
+    return selectedPackage.replace("@...", `@${version}`)
+  }
+
+  if (selectedPackage === "Enter Manually") {
+    const { packageName } = await prompts({
+      type: "text",
+      name: "packageName",
+      message: "Enter the package name",
+    })
+
+    return packageName
+  }
+
+  // TODO cache recently selected packages
+
+  return selectedPackage
+}

package/lib/param-handlers/interact-for-package-name.ts

@@ -0,0 +1,45 @@
+import { ParamHandler } from "./param-handler-type"
+import * as fs from "fs/promises"
+
+export const interactForPackageName: ParamHandler = async ({
+  prompts,
+  ctx,
+}) => {
+  // Find all package names by this user
+  const myPackages: Array<{ name: string }> = await ctx.axios
+    .post("/packages/list", {
+      is_writable: true,
+    })
+    .then((r) => r.data.packages)
+
+  // Autocomplete prompts with all packages, first option is "Enter Manually"
+  const { selectedPackage } = await prompts({
+    type: "autocomplete",
+    name: "selectedPackage",
+    message: "Select a package",
+    choices: [
+      {
+        title: "Enter Manually",
+        value: null,
+      },
+      ...myPackages.map((p) => ({
+        title: p.name,
+        value: p.name,
+      })),
+    ],
+  })
+
+  if (selectedPackage === "Enter Manually") {
+    const { packageName } = await prompts({
+      type: "text",
+      name: "packageName",
+      message: "Enter the package name",
+    })
+
+    return packageName
+  }
+
+  // TODO cache recently selected packages
+
+  return selectedPackage
+}

package/lib/param-handlers/interact-for-package-release-id.ts

@@ -0,0 +1,16 @@
+import { interactForPackageNameWithVersion } from "./interact-for-package-name-with-version"
+import { ParamHandler } from "./param-handler-type"
+
+export const interactForPackageReleaseId: ParamHandler = async (params) => {
+  const { ctx, prompts } = params
+
+  const package_name_with_version = await interactForPackageNameWithVersion(
+    params
+  )
+
+  return await ctx.axios
+    .post("/package_releases/get", {
+      package_name_with_version,
+    })
+    .then((r) => r.data.package_release.package_release_id)
+}

package/lib/param-handlers/param-handler-type.ts

@@ -0,0 +1,7 @@
+import { AppContext } from "lib/util/app-context"
+import prompts from "prompts"
+
+export type ParamHandler = (params: {
+  prompts: typeof prompts
+  ctx: AppContext
+}) => Promise<string | null | void>

package/lib/soupify.ts

@@ -0,0 +1,71 @@
+import { AppContext } from "./util/app-context"
+import { z } from "zod"
+import $ from "dax-sh"
+import * as Path from "path"
+import { unlink } from "node:fs/promises"
+import kleur from "kleur"
+import { writeFileSync } from "fs"
+
+export const soupify = async ({
+  filePath,
+  exportName,
+}: {
+  filePath: string
+  exportName?: string
+}) => {
+  const tmpFilePath = Path.join(
+    Path.dirname(filePath),
+    Path.basename(filePath).replace(/\.[^\.]+$/, "") + ".__tmp_entrypoint.tsx"
+  )
+
+  writeFileSync(
+    tmpFilePath,
+    `
+import React from "react"
+import { createRoot } from "@tscircuit/react-fiber"
+import { createProjectBuilder } from "@tscircuit/builder"
+
+import * as EXPORTS from "./${Path.basename(filePath)}"
+
+const Component = EXPORTS["${exportName}"]
+
+if (!Component) {
+  console.log(JSON.stringify({
+    COMPILE_ERROR: 'Failed to find "${exportName}" export in "${filePath}"'
+  }))
+  process.exit(0)
+}
+
+const projectBuilder = createProjectBuilder()
+const elements = await createRoot().render(<Component />, projectBuilder)
+
+console.log(JSON.stringify(elements))
+
+`.trim()
+  )
+
+  const processResult = await $`bun ${tmpFilePath}`.captureCombined(true)
+
+  const rawSoup = processResult.stdout
+  const errText = processResult.stderr
+
+  await unlink(tmpFilePath)
+
+  try {
+    const soup = JSON.parse(rawSoup)
+
+    if (soup.COMPILE_ERROR) {
+      // console.log(kleur.red(`Failed to compile ${filePath}`))
+      // console.log(soup.COMPILE_ERROR)
+      throw new Error(soup.COMPILE_ERROR)
+    }
+
+    return soup
+  } catch (e: any) {
+    // console.log(kleur.red(`Failed to parse result of soupify: ${e.toString()}`))
+    const t = Date.now()
+    console.log(`Outputting raw soupify result to .tscircuit/err-${t}.log`)
+    writeFileSync(`.tscircuit/err-${t}.log`, rawSoup + "\n\n" + errText)
+    throw e
+  }
+}

package/lib/util/app-context.ts

@@ -0,0 +1,14 @@
+import { AxiosInstance } from "axios"
+import Configstore from "configstore"
+
+export type AppContext = {
+  args: any
+  cwd: string
+  cmd: string[]
+  params: Record<string, any>
+  registry_url: string
+  axios: AxiosInstance
+  profile: string
+  profile_config: Configstore
+  global_config: Configstore
+}