@tscircuit/cli 0.0.393 → 0.1.1

package/cli/lib/param-handlers/interact-for-registry-url.ts

@@ -1,27 +0,0 @@
-import { ParamHandler } from "./param-handler-type"
-
-export const interactForRegistryUrl: ParamHandler = async (params) => {
-  const { prompts, ctx } = params
-
-  const { registry_url } = await prompts({
-    type: "select",
-    name: "registry_url",
-    message: "Select a package example",
-    choices: [
-      "https://registry-api.tscircuit.com",
-      "http://127.0.0.1:3100",
-      "other",
-    ].map((a) => ({ title: a, value: a })),
-  })
-
-  if (registry_url === "other") {
-    const { registry_url } = await prompts({
-      type: "text",
-      name: "registry_url",
-      message: "Enter the registry url",
-    })
-    return registry_url
-  }
-
-  return registry_url
-}

package/cli/lib/param-handlers/interact-for-runtime.ts

@@ -1,33 +0,0 @@
-import kleur from "kleur"
-import { ParamHandler } from "./param-handler-type"
-import $ from "dax-sh"
-
-export const interactForRuntime: ParamHandler = async (params) => {
-  const { prompts, ctx } = params
-
-  const bunVersion = await $`bun --version`.text().catch((e) => null)
-
-  if (!bunVersion) {
-    console.log(
-      kleur.red(`BUN IS NOT INSTALLED! Install bun first https://bun.sh/`),
-    )
-  }
-
-  const { runtime } = await prompts({
-    type: "select",
-    name: "runtime",
-    message: "Select a runtime",
-    choices: [
-      {
-        title: "bun",
-        value: "bun",
-        description: bunVersion
-          ? `bun version: ${bunVersion}`
-          : "NOTE: bun not installed, install bun first!",
-      },
-      { title: "node", value: "node" },
-    ],
-  })
-
-  return runtime
-}

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

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

package/cli/lib/posthog.ts

@@ -1,23 +0,0 @@
-import { PostHog } from "posthog-node"
-
-const POSTHOG_API_KEY: string | undefined = process.env.POSTHOG_API_KEY
-
-let posthogInstance: PostHog | null = null
-
-if (POSTHOG_API_KEY) {
-  posthogInstance = new PostHog(POSTHOG_API_KEY, {
-    host: "https://us.i.posthog.com",
-  })
-}
-
-const posthogProxy = new Proxy<PostHog>({} as PostHog, {
-  get(target, prop) {
-    if (posthogInstance) {
-      return Reflect.get(posthogInstance, prop)
-    }
-    // Return a no-op function for any method call if PostHog is not initialized
-    return () => {}
-  },
-})
-
-export default posthogProxy

package/cli/lib/soupify/get-export-name-from-file.ts

@@ -1,29 +0,0 @@
-import { readFile } from "node:fs/promises"
-import Debug from "debug"
-
-const debug = Debug("tscircuit:soupify")
-
-export const getExportNameFromFile = async (filePath: string) => {
-  debug(`reading ${filePath}`)
-  const targetFileContent = await readFile(filePath, "utf-8")
-
-  let exportName: string | undefined
-  if (targetFileContent.includes("export default")) {
-    exportName = "default"
-  } else {
-    // Look for "export const <name>" or "export function <name>"
-    const exportRegex = /export\s+(?:const|function)\s+(\w+)/g
-    const match = exportRegex.exec(targetFileContent)
-    if (match) {
-      exportName = match[1]
-    }
-  }
-
-  if (!exportName) {
-    throw new Error(
-      `Couldn't derive an export name and didn't find default export in "${filePath}"`,
-    )
-  }
-
-  return exportName
-}

package/cli/lib/soupify/get-tmp-entrpoint-filepath.ts

@@ -1,15 +0,0 @@
-import Path from "node:path/posix"
-import fs from "fs/promises"
-
-export const getTmpEntrypointFilePath = async (filePath: string) => {
-  const tmpEntrypointPath = Path.resolve(
-    Path.dirname(filePath),
-    Path.basename(filePath).replace(/\.[^\.]+$/, "") + ".__tmp_entrypoint.tsx",
-  )
-  const tmpOutputPath = Path.resolve(
-    Path.dirname(filePath),
-    Path.basename(filePath).replace(/\.[^\.]+$/, "") + ".__tmp_output.json",
-  )
-
-  return { tmpEntrypointPath, tmpOutputPath }
-}

package/cli/lib/soupify/index.ts

@@ -1 +0,0 @@
-export * from "./soupify"

package/cli/lib/soupify/run-entrypoint-file.ts

@@ -1,59 +0,0 @@
-import Debug from "debug"
-import { writeFileSync } from "fs"
-import { readFile, unlink } from "node:fs/promises"
-import $ from "dax-sh"
-import kleur from "kleur"
-import { AppContext } from "../util/app-context"
-
-const debug = Debug("tscircuit:soupify")
-
-/**
- * Runs the entrypoint file to generate circuit json (soup) for a given file
- */
-export const runEntrypointFile = async (
-  {
-    tmpEntrypointPath,
-    tmpOutputPath,
-  }: { tmpEntrypointPath: string; tmpOutputPath: string },
-  ctx: Pick<AppContext, "runtime" | "params">,
-) => {
-  debug(`using runtime ${ctx.runtime}`)
-  const processCmdPart1 =
-    ctx.runtime === "node"
-      ? $`npx tsx ${tmpEntrypointPath}`
-      : $`bun ${tmpEntrypointPath}`
-  debug(`starting process....`)
-
-  const processResult = await processCmdPart1
-    .stderr(debug.enabled ? "inheritPiped" : "piped")
-    .stdout(debug.enabled ? "inheritPiped" : "piped")
-    .noThrow()
-
-  const rawSoup = await readFile(tmpOutputPath, "utf-8")
-  const errText = processResult.stderr
-
-  if (ctx.params.cleanup !== false) {
-    debug(`deleting ${tmpEntrypointPath}`)
-    await unlink(tmpEntrypointPath)
-    debug(`deleting ${tmpOutputPath}`)
-    await unlink(tmpOutputPath)
-  }
-
-  try {
-    debug(`parsing result of soupify...`)
-    const soup = JSON.parse(rawSoup)
-
-    if (soup.COMPILE_ERROR) {
-      // console.log(kleur.red(`Failed to compile ${filePath}`))
-      console.log(kleur.red(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(`Dumping raw output to .tscircuit/err-${t}.log`)
-    writeFileSync(`.tscircuit/err-${t}.log`, rawSoup + "\n\n" + errText)
-    throw new Error(errText)
-  }
-}

package/cli/lib/soupify/soupify-with-core.ts

@@ -1,74 +0,0 @@
-import { AppContext } from "../util/app-context"
-import { z } from "zod"
-import $ from "dax-sh"
-import * as Path from "path/posix"
-import { unlink } from "node:fs/promises"
-import kleur from "kleur"
-import { writeFileSync } from "fs"
-import { readFile } from "fs/promises"
-import Debug from "debug"
-import { getExportNameFromFile } from "./get-export-name-from-file"
-import { getTmpEntrypointFilePath } from "./get-tmp-entrpoint-filepath"
-import { runEntrypointFile } from "./run-entrypoint-file"
-import fs from "node:fs/promises"
-
-const debug = Debug("tscircuit:soupify")
-
-export const soupifyWithCore = async (
-  params: {
-    filePath: string
-    exportName?: string
-  },
-  ctx: Pick<AppContext, "runtime" | "params">,
-) => {
-  let { filePath, exportName } = params
-
-  exportName ??= await getExportNameFromFile(filePath)
-
-  const { tmpEntrypointPath, tmpOutputPath } =
-    await getTmpEntrypointFilePath(filePath)
-
-  // Remove existing entrypoint or tmp output files
-  await fs.unlink(tmpEntrypointPath).catch(() => {})
-  await fs.unlink(tmpOutputPath).catch(() => {})
-
-  debug(`writing to ${tmpEntrypointPath}`)
-  writeFileSync(
-    tmpEntrypointPath,
-    `
-import React from "react"
-import { Circuit } from "@tscircuit/core"
-import * as EXPORTS from "./${Path.basename(filePath)}"
-import { writeFileSync } from "node:fs"
-
-const Component = EXPORTS["${exportName}"]
-
-const project = new Circuit()
-
-try {
-  project.add(<Component />)
-} catch (e: any) {
-  console.log("[during .add()] ", e.toString())
-  writeFileSync("${tmpOutputPath}", JSON.stringify({
-    COMPILE_ERROR: e.toString() + "\\n\\n" + e.stack,
-  }))
-  throw e
-}
-
-try {
-  project.render()
-} catch (e: any) {
-  console.log(e.toString())
-  writeFileSync("${tmpOutputPath}", JSON.stringify({
-    COMPILE_ERROR: e.toString() + "\\n\\n" + e.stack,
-  }))
-  throw e
-}
-
-
-writeFileSync("${tmpOutputPath}", JSON.stringify(project.getCircuitJson()))
-`.trim(),
-  )
-
-  return await runEntrypointFile({ tmpEntrypointPath, tmpOutputPath }, ctx)
-}

package/cli/lib/soupify/soupify.ts

@@ -1,6 +0,0 @@
-import Debug from "debug"
-import { soupifyWithCore } from "./soupify-with-core"
-
-const debug = Debug("tscircuit:soupify")
-
-export const soupify = soupifyWithCore

package/cli/lib/util/app-context.ts

@@ -1,17 +0,0 @@
-import { AxiosInstance } from "axios"
-import { ContextConfigProps } from "cli/lib/create-config-manager"
-
-export type AppContext = {
-  args: {
-    cmd: string[]
-    yes: boolean
-    help: boolean | undefined
-  }
-  cwd: string
-  cmd: string[]
-  params: Record<string, any>
-  registry_url: string
-  axios: AxiosInstance
-  current_profile: string
-  runtime: "node" | "bun"
-} & ContextConfigProps

package/cli/lib/util/create-context-and-run-program.ts

@@ -1,168 +0,0 @@
-import Configstore from "configstore"
-import type { AppContext } from "./app-context"
-import minimist from "minimist"
-import _ from "lodash"
-import prompts from "prompts"
-import { perfectCli } from "perfect-cli"
-import { getProgram } from "../get-program"
-import defaultAxios from "axios"
-import kleur from "kleur"
-import { PARAM_HANDLERS_BY_PARAM_NAME } from "cli/lib/param-handlers"
-import { createConfigHandler } from "cli/lib/create-config-manager"
-import dargs from "dargs"
-import { versionCmd } from "cli/lib/cmd-fns/version"
-
-export type CliArgs = {
-  cmd: string[]
-  yes?: boolean
-  help?: boolean
-}
-
-export const createContextAndRunProgram = async (process_args: string[]) => {
-  const args = minimist(process_args)
-
-  const { global_config, profile_config, current_profile } =
-    createConfigHandler({
-      profile: args.profile,
-    })
-
-  // Load registry commands
-  const registry_url =
-    profile_config.get("registry_url") ?? "https://registry-api.tscircuit.com"
-
-  // TODO don't replace non-command args with underscores
-  args._ = args._.map((p: string) => p.toLowerCase().replace(/-/g, "_"))
-
-  // If flags are provided with dashes, switch them to underscores
-  for (const key in args) {
-    if (key.includes("-")) {
-      args[key.replace(/-/g, "_")] = args[key]
-      delete args[key]
-    }
-  }
-
-  const axios = defaultAxios.create({
-    baseURL: registry_url,
-    headers: {
-      Authorization: `Bearer ${profile_config.get("session_token")}`,
-    },
-  })
-
-  // https://github.com/oven-sh/bun/issues/267
-  axios.defaults.headers.common["Accept-Encoding"] = "gzip"
-
-  if (global_config.get("log_requests")) {
-    console.log(`Using registry_url: ${registry_url}`)
-    axios.interceptors.request.use((req) => {
-      console.log(kleur.grey(`[REQ] ${req.method?.toUpperCase()} ${req.url}`))
-      return req
-    })
-    axios.interceptors.response.use((res) => {
-      console.log(
-        kleur.grey(
-          `[RES] ${res.status} ${res.config.method?.toUpperCase()} ${
-            res.config.url
-          }`,
-        ),
-      )
-      return res
-    })
-  }
-
-  axios.interceptors.response.use(
-    (res) => res,
-    (err) => {
-      // ---- IGNORE LOGGING *_not_found --------
-      if (
-        err.config.data?.error?.error_code === "package_not_found" ||
-        err.config.data?.error?.error_code === "package_release_not_found"
-      ) {
-        return Promise.reject(err)
-      }
-      // end ignores ---
-
-      if (err.response?.status === 401) {
-        console.log(
-          kleur.red(
-            "Authentication failed. Please run 'tsci login' to authenticate yourself.",
-          ),
-        )
-        process.exit(1)
-      }
-
-      console.log(
-        kleur.red(
-          `[ERR] ${err.response?.status} ${err.config.method?.toUpperCase()} ${
-            err.config.url
-          }\n\n${JSON.stringify(err.response?.data, null, "  ")}`
-            .replace(/\\n/g, "\n")
-            .replace(/\\"/g, '"'),
-        ),
-      )
-      console.log(kleur.yellow("[Request Body]:"), err.config.data)
-      return Promise.reject(err)
-    },
-  )
-
-  function isBunRuntime() {
-    return typeof process !== "undefined" && "isBun" in process
-  }
-
-  const ctx: AppContext = {
-    cmd: args._,
-    cwd: args.cwd ?? process.cwd(),
-    current_profile,
-    registry_url,
-    axios,
-    global_config,
-    profile_config,
-    runtime: isBunRuntime() ? "bun" : (global_config.get("runtime") ?? "node"),
-    args: {
-      cmd: args._,
-      yes: args.y ?? args.yes,
-      help: undefined,
-    },
-    params: args,
-  }
-
-  if (args["color"] === false) {
-    kleur.enabled = false
-  }
-
-  delete args["cwd"]
-  delete args["color"]
-
-  const { _: positional, ...flagsAndParams } = args
-  const args_without_globals = positional.concat(dargs(flagsAndParams))
-
-  if (args["version"] && args._.length === 2) {
-    await versionCmd(ctx, {})
-    process.exit(0)
-  }
-
-  // HACK: Fixes issue with tsci version --show-latest
-  if (args_without_globals.includes("--show_latest")) {
-    args_without_globals[args_without_globals.indexOf("--show_latest")] =
-      "--show-latest"
-  }
-
-  await perfectCli(getProgram(ctx), args_without_globals, {
-    async customParamHandler({ commandPath, optionName }, { prompts }) {
-      let optionNameHandler =
-        PARAM_HANDLERS_BY_PARAM_NAME[_.snakeCase(optionName)]
-
-      if (
-        commandPath.join(" ") === "config set-registry" &&
-        optionName === "server"
-      ) {
-        optionNameHandler = PARAM_HANDLERS_BY_PARAM_NAME["registry_url"]
-      }
-
-      if (optionNameHandler) {
-        return optionNameHandler({ prompts, ctx })
-      }
-    },
-  })
-
-  return ctx
-}

package/cli/lib/util/get-all-package-files.ts

@@ -1,66 +0,0 @@
-import * as fs from "fs/promises"
-import { AppContext } from "./app-context"
-import * as Glob from "glob"
-import ignore from "ignore"
-
-/**
- * Get all package files
- *
- * Package files are any files that aren't explicitly ignored in the
- * .npmignore (or if that doesn't exist, the .gitignore). All package
- * files must have a .ts or .tsx extension.
- *
- * Returns an array of files paths.
- */
-export const getAllPackageFiles = async (
-  ctx: AppContext,
-): Promise<Array<string>> => {
-  await ensureNodeModulesIgnored()
-
-  const [gitIgnore, promptIgnore, npmIgnore] = await Promise.all([
-    readIgnoreFile("./.gitignore"),
-    readIgnoreFile("./.promptignore"),
-    readIgnoreFile("./.npmignore"),
-  ])
-
-  const npmAndPromptIgnoreFiles = [
-    ...(promptIgnore ?? []),
-    ...(npmIgnore ?? []),
-  ]
-
-  const ig = ignore().add([
-    ...(npmAndPromptIgnoreFiles.length > 0
-      ? npmAndPromptIgnoreFiles
-      : (gitIgnore ?? [])),
-    ".tscircuit",
-    "node_modules/*",
-  ])
-
-  return Glob.globSync("**/*.{ts,tsx,md}", {}).filter((fp) => !ig.ignores(fp))
-}
-
-const readIgnoreFile = async (filePath: string): Promise<string[] | null> =>
-  await fs
-    .readFile(filePath)
-    .then((b) => b.toString().split("\n").filter(Boolean))
-    .catch((e) => null)
-
-/**
- * Ensure 'node_modules/' is in .gitignore
- */
-const ensureNodeModulesIgnored = async () => {
-  const gitignorePath = "./.gitignore"
-
-  try {
-    const gitignore = await fs.readFile(gitignorePath, "utf8")
-    if (!gitignore.includes("node_modules/")) {
-      await fs.appendFile(gitignorePath, "\nnode_modules/\n")
-    }
-  } catch (err) {
-    if ((err as NodeJS.ErrnoException).code === "ENOENT") {
-      await fs.writeFile(gitignorePath, "node_modules/\n")
-    } else {
-      console.error("Error while updating .gitignore:", err)
-    }
-  }
-}

package/cli/lib/util/lint-project.ts

@@ -1,137 +0,0 @@
-import * as ts from "typescript"
-import * as fs from "fs"
-import * as path from "path/posix"
-
-interface LintResult {
-  filePath: string
-  messages: LintMessage[]
-}
-
-interface LintMessage {
-  line: number
-  column: number
-  message: string
-  fix?: {
-    range: [number, number]
-    text: string
-  }
-}
-
-export function lintProject(
-  projectPath: string,
-  fix: boolean = false,
-): LintResult[] {
-  const results: LintResult[] = []
-  const files = getTypeScriptFiles(projectPath)
-
-  for (const file of files) {
-    const sourceFile = ts.createSourceFile(
-      file,
-      fs.readFileSync(file, "utf8"),
-      ts.ScriptTarget.Latest,
-      true,
-    )
-
-    const result = lintFile(sourceFile, fix)
-    if (result.messages.length > 0) {
-      results.push({ filePath: file, messages: result.messages })
-    }
-
-    if (fix && result.messages.some((m) => m.fix)) {
-      const newContent = applyFixes(sourceFile.text, result.messages)
-      fs.writeFileSync(file, newContent)
-    }
-  }
-
-  return results
-}
-
-function lintFile(
-  sourceFile: ts.SourceFile,
-  fix: boolean,
-): { messages: LintMessage[] } {
-  const messages: LintMessage[] = []
-
-  function visit(node: ts.Node) {
-    if (
-      ts.isCallExpression(node) &&
-      ts.isIdentifier(node.expression) &&
-      node.expression.text === "capacitor"
-    ) {
-      const valueArg = node.arguments.find((arg) =>
-        ts.isObjectLiteralExpression(arg),
-      )
-      if (valueArg && ts.isObjectLiteralExpression(valueArg)) {
-        const valueProp = valueArg.properties.find(
-          (prop) =>
-            ts.isPropertyAssignment(prop) &&
-            ts.isIdentifier(prop.name) &&
-            prop.name.text === "value",
-        )
-        if (
-          valueProp &&
-          ts.isPropertyAssignment(valueProp) &&
-          ts.isStringLiteral(valueProp.initializer)
-        ) {
-          const value = valueProp.initializer.text
-          if (!value.match(/[µuμ]F$/)) {
-            const { line, character } =
-              sourceFile.getLineAndCharacterOfPosition(valueProp.getStart())
-            messages.push({
-              line: line + 1,
-              column: character + 1,
-              message: 'Capacitor value should include units (e.g., "100F")',
-              fix: fix
-                ? {
-                    range: [
-                      valueProp.initializer.getStart(),
-                      valueProp.initializer.getEnd(),
-                    ],
-                    text: `"${value}F"`,
-                  }
-                : undefined,
-            })
-          }
-        }
-      }
-    }
-
-    ts.forEachChild(node, visit)
-  }
-
-  visit(sourceFile)
-
-  return { messages }
-}
-
-function getTypeScriptFiles(dir: string): string[] {
-  const files: string[] = []
-  const entries = fs.readdirSync(dir, { withFileTypes: true })
-
-  for (const entry of entries) {
-    const fullPath = path.join(dir, entry.name)
-    if (entry.isDirectory()) {
-      if (entry.name !== "node_modules" && entry.name !== "dist") {
-        files.push(...getTypeScriptFiles(fullPath))
-      }
-    } else if (entry.isFile() && /\.tsx?$/.test(entry.name)) {
-      files.push(fullPath)
-    }
-  }
-
-  return files
-}
-
-function applyFixes(source: string, messages: LintMessage[]): string {
-  const fixes = messages
-    .filter((m) => m.fix)
-    .sort((a, b) => b.fix!.range[0] - a.fix!.range[0])
-
-  let result = source
-  for (const message of fixes) {
-    const [start, end] = message.fix!.range
-    result = result.slice(0, start) + message.fix!.text + result.slice(end)
-  }
-
-  return result
-}

package/cli/tests/export-gerber-keyboard.test.ts

@@ -1,16 +0,0 @@
-import { test, expect, describe } from "bun:test"
-import { $ } from "bun"
-import { temporaryDirectory } from "tempy"
-import { join } from "path/posix"
-import { existsSync } from "fs"
-
-test("tsci export gerbers --input example-project/examples/macrokeypad.tsx", async () => {
-  const tempDir = temporaryDirectory()
-  const { stdout, stderr } =
-    await $`bun cli/cli.ts export gerbers --input example-project/examples/macrokeypad.tsx --outputfile ${join(tempDir, "gerbers.zip")} --no-color`
-
-  expect(stderr.toString()).toBe("")
-  expect(stdout.toString()).toContain("gerbers.zip")
-
-  expect(existsSync(join(tempDir, "gerbers.zip"))).toBe(true)
-})