@tscircuit/cli 0.0.393 → 0.1.1

package/cli/lib/cmd-fns/dev/start-dev-server.ts

@@ -1,34 +0,0 @@
-import { AxiosInstance } from "axios"
-import { devServerRequestHandler } from "./dev-server-request-handler"
-
-export const startDevServer = async ({
-  port,
-  devServerAxios,
-}: {
-  port: number
-  devServerAxios: AxiosInstance
-}) => {
-  let server: any
-  if (typeof Bun !== "undefined") {
-    server = Bun.serve({
-      fetch: devServerRequestHandler,
-      development: false,
-      port,
-    })
-  } else {
-    // Hono messes up the globals, only import it if we don't have Bun
-    const { Hono } = await import("hono")
-    const { serve } = await import("@hono/node-server")
-    const honoApp = new Hono()
-    honoApp.all("/*", (c) => devServerRequestHandler(c.req.raw))
-    server = serve({
-      fetch: honoApp.fetch,
-      port,
-    })
-  }
-
-  console.log("Running health check against dev server...")
-  await devServerAxios.get("/api/health")
-
-  return server
-}

package/cli/lib/cmd-fns/dev/start-edit-event-watcher.ts

@@ -1,347 +0,0 @@
-import type { DevPackageExample } from "api/db/schema"
-import type { AxiosInstance } from "axios"
-import kleur from "kleur"
-import { AppContext } from "cli/lib/util/app-context"
-import fg from "fast-glob"
-import fs from "fs"
-import { Project, ts } from "ts-morph"
-import * as Path from "path/posix"
-import { deriveSelectorFromPcbComponentId } from "./derive-selector-from-pcb-component-id"
-import type { EditEvent } from "@tscircuit/manual-edit-events"
-import {
-  getManualTraceHintFromEvent,
-  ManualTraceHint,
-  ManualEditFile,
-} from "@tscircuit/layout"
-import JSON5 from "json5"
-import Debug from "debug"
-
-const debug = Debug("tscircuit:cli:edit-event-watcher")
-
-type ManualPcbPosition = Required<ManualEditFile>["pcb_placements"][number]
-
-export const startEditEventWatcher = async (
-  {
-    devServerAxios,
-  }: {
-    devServerAxios: AxiosInstance
-  },
-  ctx: AppContext,
-) => {
-  let running = true
-  ;(async () => {
-    let last_edit_event_update_time: Record<string, string> = {}
-
-    while (running) {
-      try {
-        const dev_package_examples: DevPackageExample[] = await devServerAxios
-          .post("/api/dev_package_examples/list", {})
-          .then((r) => r.data.dev_package_examples)
-
-        for (const dev_package_example of dev_package_examples) {
-          const dev_package_example_id: number =
-            dev_package_example.dev_package_example_id as any
-
-          const last_recorded_update_time =
-            last_edit_event_update_time[dev_package_example_id]
-
-          if (
-            last_recorded_update_time !==
-            dev_package_example.edit_events_last_updated_at
-          ) {
-            console.log(
-              kleur.gray(
-                `Edit event detected for dev_package_example ${dev_package_example.dev_package_example_id}`,
-              ),
-            )
-            debug(`file_path: ${dev_package_example.file_path}`)
-
-            last_edit_event_update_time[dev_package_example_id] =
-              dev_package_example.edit_events_last_updated_at! // TODO last_edit_event_updated_at
-
-            debug(`  getting new edit events...`)
-
-            const dev_package_example_full = await devServerAxios
-              .post("/api/dev_package_examples/get", {
-                dev_package_example_id,
-              })
-              .then((r) => r.data.dev_package_example)
-
-            // 1. Find the *.manual-edits.ts, if there are multiple error
-            const manual_edit_files = fg.sync(
-              ["**/*.manual-edits.ts", "**/manual-edits.ts"],
-              {
-                cwd: ctx.cwd,
-                ignore: ["node_modules"],
-              },
-            )
-
-            if (manual_edit_files.length === 0) {
-              console.log(
-                kleur.red(
-                  `No manual edit files found in "${ctx.cwd}", please create a file "manual-edits.ts" or "*.manual-edits.ts" to persist manual edits`,
-                ),
-              )
-              continue
-            }
-
-            if (manual_edit_files.length > 1) {
-              console.log(
-                kleur.red(
-                  `Multiple manual edit files found, tsci currently doesn't know how to handle this, you should go upvote an issue`,
-                ),
-              )
-              for (let i = 0; i < manual_edit_files.length; i++) {
-                console.log(
-                  kleur.gray(`  file ${i + 1}: ${manual_edit_files[i]}`),
-                )
-              }
-              continue
-            }
-
-            const manual_edit_file = manual_edit_files[0]
-            const manual_edit_file_content = fs.readFileSync(
-              Path.join(ctx.cwd, manual_edit_file),
-              "utf-8",
-            )
-
-            debug(`  found manual edit file: ${manual_edit_file}`)
-
-            // 2. Convert the edit events into ManualPcbPosition[] and append,
-            //    removing any old placements/positions for the same selector.
-            //    We can completely rewrite the file here for now (we'll need
-            //    to preserve comments etc. later)
-
-            const edit_events: EditEvent[] =
-              dev_package_example_full.completed_edit_events ?? []
-
-            if (edit_events.length === 0) continue
-
-            const project = new Project()
-
-            const ts_manual_edits_file = project.createSourceFile(
-              "manual-edits.ts",
-              manual_edit_file_content,
-            )
-
-            // Access the default export declaration
-            const default_export_dec = ts_manual_edits_file
-              .getDefaultExportSymbol()!
-              .getDeclarations()[0]
-
-            // Get the object literal expression from the export default statement
-            const object_literal =
-              default_export_dec.getFirstChildByKindOrThrow(
-                ts.SyntaxKind.ObjectLiteralExpression,
-              )
-
-            // Get the `pcb_placements` property
-            const pcb_placements_ts =
-              object_literal.getPropertyOrThrow("pcb_placements")
-
-            if (object_literal.getProperty("edit_events") === undefined) {
-              object_literal.addPropertyAssignment({
-                name: "edit_events",
-                initializer: "[]",
-              })
-            }
-
-            const edit_events_ts =
-              object_literal.getPropertyOrThrow("edit_events")
-
-            if (
-              object_literal.getProperty("manual_trace_hints") === undefined
-            ) {
-              object_literal.addPropertyAssignment({
-                name: "manual_trace_hints",
-                initializer: "[]",
-              })
-            }
-            const manual_trace_hints_ts =
-              object_literal.getPropertyOrThrow("manual_trace_hints")
-
-            let pcb_placements: (ManualPcbPosition & {
-              _edit_event_id?: string
-            })[]
-            let in_file_edit_events: EditEvent[]
-            let manual_trace_hints: ManualTraceHint[]
-            try {
-              pcb_placements = JSON5.parse(
-                pcb_placements_ts.getText().replace(/pcb_placements:\s/, ""),
-              )
-            } catch (e: any) {
-              console.log(
-                kleur.red(
-                  `Error parsing pcb_placements from manual edits file: ${pcb_placements_ts.getText()} ${e.toString()}`,
-                ),
-              )
-              continue
-            }
-            try {
-              in_file_edit_events = JSON5.parse(
-                edit_events_ts.getText().replace(/edit_events:\s/, ""),
-              )
-            } catch (e: any) {
-              console.log(
-                kleur.red(
-                  `Error parsing edit_events from manual edits file: ${edit_events_ts.getText()} ${e.toString()}`,
-                ),
-              )
-              continue
-            }
-            try {
-              manual_trace_hints = JSON5.parse(
-                manual_trace_hints_ts
-                  .getText()
-                  .replace(/manual_trace_hints:\s/, ""),
-              )
-            } catch (e: any) {
-              console.log(
-                kleur.red(
-                  `Error parsing manual_trace_hints from manual edits file: ${pcb_placements_ts.getText()} ${e.toString()}`,
-                ),
-              )
-              continue
-            }
-
-            const handled_edit_events = new Set<string>(
-              pcb_placements
-                .map((p) => (p as any)._edit_event_id)
-                .concat(in_file_edit_events.map((a) => a.edit_event_id)),
-            )
-
-            // Add PCB placements from edit events
-            for (const incoming_edit_event of edit_events) {
-              if (handled_edit_events.has(incoming_edit_event.edit_event_id))
-                continue
-
-              debug(
-                `incoming_edit_event: ${JSON.stringify(incoming_edit_event)}`,
-              )
-
-              if (
-                incoming_edit_event.pcb_edit_event_type ===
-                "edit_component_location"
-              ) {
-                // TODO Figure out a good selector for this pcb_component
-                let pcb_component_selector: string | null = null
-                if (incoming_edit_event.pcb_component_id) {
-                  pcb_component_selector = deriveSelectorFromPcbComponentId({
-                    soup: dev_package_example_full.tscircuit_soup,
-                    pcb_component_id: incoming_edit_event.pcb_component_id,
-                  })
-                }
-
-                debug(
-                  `edit event pcb_component_selector: "${pcb_component_selector}"`,
-                )
-
-                // TODO we'll need to work past this for edit_event_type=edit_trace
-                if (!pcb_component_selector) continue
-
-                const existing_placement_for_selector = pcb_placements.find(
-                  (pp) => pp.selector === pcb_component_selector,
-                )
-
-                if (!existing_placement_for_selector) {
-                  console.log(
-                    kleur.gray(
-                      `  adding PCB placement from edit event for "${pcb_component_selector}"`,
-                    ),
-                  )
-
-                  pcb_placements.push({
-                    _edit_event_id: incoming_edit_event.edit_event_id,
-                    selector: pcb_component_selector,
-                    center: incoming_edit_event.new_center,
-                    relative_to: "group_center",
-                  })
-                } else {
-                  existing_placement_for_selector.center =
-                    incoming_edit_event.new_center
-                }
-
-                // Edit the pcb placements object
-                pcb_placements_ts.replaceWithText(
-                  `pcb_placements: ${JSON.stringify(
-                    pcb_placements,
-                    null,
-                    "  ",
-                  )}`,
-                )
-
-                // Save the file
-                fs.writeFileSync(
-                  Path.join(ctx.cwd, manual_edit_file),
-                  ts_manual_edits_file.getFullText(),
-                )
-                await devServerAxios.post("/api/dev_package_examples/update", {
-                  dev_package_example_id,
-                  edit_events_last_applied_at:
-                    dev_package_example.edit_events_last_updated_at,
-                })
-              } else if (
-                incoming_edit_event.pcb_edit_event_type === "edit_trace_hint"
-              ) {
-                const new_trace_hint = getManualTraceHintFromEvent(
-                  dev_package_example_full.tscircuit_soup,
-                  incoming_edit_event,
-                )
-
-                manual_trace_hints_ts.replaceWithText(
-                  `manual_trace_hints: ${JSON.stringify(
-                    manual_trace_hints
-                      .filter(
-                        (th) =>
-                          th.pcb_port_selector !==
-                          new_trace_hint.pcb_port_selector,
-                      )
-                      .concat([new_trace_hint]),
-                    null,
-                    "  ",
-                  )}`,
-                )
-
-                fs.writeFileSync(
-                  Path.join(ctx.cwd, manual_edit_file),
-                  ts_manual_edits_file.getFullText(),
-                )
-                await devServerAxios.post("/api/dev_package_examples/update", {
-                  dev_package_example_id,
-                  edit_events_last_applied_at:
-                    dev_package_example.edit_events_last_updated_at,
-                })
-              } else {
-                // All other events just go to the manual-edits.ts file with
-                // in the "edit_events" property
-                edit_events_ts.replaceWithText(
-                  `edit_events: ${JSON.stringify(edit_events, null, "  ")}`,
-                )
-                console.log(edit_events_ts.getFullText())
-                fs.writeFileSync(
-                  Path.join(ctx.cwd, manual_edit_file),
-                  ts_manual_edits_file.getFullText(),
-                )
-                await devServerAxios.post("/api/dev_package_examples/update", {
-                  dev_package_example_id,
-                  edit_events_last_applied_at:
-                    dev_package_example.edit_events_last_updated_at,
-                })
-              }
-            }
-          }
-        }
-      } catch (err: any) {
-        console.log(kleur.red(`Error in edit event watcher: ${err.toString()}`))
-      }
-
-      await new Promise((resolve) => setTimeout(resolve, 100))
-    }
-  })()
-
-  return {
-    stop: () => {
-      running = false
-    },
-  }
-}

package/cli/lib/cmd-fns/dev/start-export-request-watcher.ts

@@ -1,33 +0,0 @@
-import { AxiosInstance } from "axios"
-import kleur from "kleur"
-import { fulfillExportRequests } from "./fulfill-export-requests"
-import { AppContext } from "cli/lib/util/app-context"
-
-export const startExportRequestWatcher = async (
-  {
-    devServerAxios,
-  }: {
-    devServerAxios: AxiosInstance
-  },
-  ctx: AppContext,
-) => {
-  let running = true
-  ;(async () => {
-    while (running) {
-      try {
-        await fulfillExportRequests({ dev_server_axios: devServerAxios }, ctx)
-      } catch (err: any) {
-        console.log(
-          kleur.red(`Error in export request watcher: ${err.toString()}`),
-        )
-      }
-      await new Promise((resolve) => setTimeout(resolve, 1000))
-    }
-  })()
-
-  return {
-    stop: () => {
-      running = false
-    },
-  }
-}

package/cli/lib/cmd-fns/dev/start-fs-watcher.ts

@@ -1,54 +0,0 @@
-import { AxiosInstance } from "axios"
-import chokidar from "chokidar"
-import { uploadExamplesFromDirectory } from "./upload-examples-from-directory"
-import kleur from "kleur"
-import { AppContext } from "cli/lib/util/app-context"
-
-export const startFsWatcher = async (
-  {
-    cwd,
-    devServerAxios,
-  }: {
-    cwd: string
-    devServerAxios: AxiosInstance
-  },
-  ctx: Pick<AppContext, "runtime" | "params">,
-) => {
-  const watcher = chokidar.watch([`${cwd}/**/*.tsx`, `${cwd}/**/*.ts`], {
-    ignored: /node_modules/,
-    persistent: true,
-  })
-
-  const upload_queue_state = {
-    dirty: false,
-    should_run: true,
-  }
-  watcher.on("change", async (path) => {
-    console.log(path)
-    if (path.endsWith(".__tmp_entrypoint.tsx")) return
-    console.log(`File ${path} has been changed`)
-    // TODO analyze to determine which examples were impacted
-    upload_queue_state.dirty = true
-  })
-
-  async function uploadInBackground() {
-    while (upload_queue_state.should_run) {
-      if (upload_queue_state.dirty) {
-        console.log(kleur.yellow("Changes detected, re-uploading examples..."))
-        upload_queue_state.dirty = false
-        await uploadExamplesFromDirectory({ cwd, devServerAxios }, ctx)
-      }
-      await new Promise((resolve) => setTimeout(resolve, 100))
-    }
-  }
-
-  const _backgroundUploaderPromise = uploadInBackground()
-
-  return {
-    _backgroundUploaderPromise,
-    stop: () => {
-      upload_queue_state.should_run = false
-      watcher.close()
-    },
-  }
-}

package/cli/lib/cmd-fns/dev/upload-examples-from-directory.ts

@@ -1,42 +0,0 @@
-import kleur from "kleur"
-import { join as joinPath } from "path/posix"
-import { AxiosInstance } from "axios"
-import { readdirSync, readFileSync } from "fs"
-import { soupify } from "cli/lib/soupify"
-import { soupifyAndUploadExampleFile } from "./soupify-and-upload-example-file"
-import { markAllExamplesLoading } from "./mark-all-examples-loading"
-import { readdir } from "fs/promises"
-import { AppContext } from "cli/lib/util/app-context"
-
-export const uploadExamplesFromDirectory = async (
-  {
-    cwd,
-    devServerAxios,
-  }: {
-    cwd: string
-    devServerAxios: AxiosInstance
-  },
-  ctx: Pick<AppContext, "runtime" | "params">,
-) => {
-  const examplesDir = joinPath(cwd, "examples")
-  const exampleFileNames = await readdir(examplesDir).catch((e) => {
-    console.log(kleur.red(`Error reading examples directory: "${examplesDir}"`))
-    throw e
-  })
-
-  // Mark all examples as being "reloaded" in the database
-  await markAllExamplesLoading({ devServerAxios })
-
-  for (const exampleFileName of exampleFileNames) {
-    if (exampleFileName.endsWith(".__tmp_entrypoint.tsx")) continue
-    if (!exampleFileName.endsWith(".tsx")) continue
-    await soupifyAndUploadExampleFile(
-      {
-        devServerAxios,
-        examplesDir,
-        exampleFileName,
-      },
-      ctx,
-    )
-  }
-}

package/cli/lib/cmd-fns/dev-server-fulfill-export-requests.ts

@@ -1,43 +0,0 @@
-import kleur from "kleur"
-import { z } from "zod"
-import { AppContext } from "../util/app-context"
-import { fulfillExportRequests } from "./dev/fulfill-export-requests"
-import { getDevServerAxios } from "./dev/get-dev-server-axios"
-
-export const devServerFulfillExportRequests = async (
-  ctx: AppContext,
-  args: any,
-) => {
-  const params = z.object({}).parse(args)
-
-  let server_url = `http://127.0.0.1:3020`
-  let dev_server_axios = getDevServerAxios({ serverUrl: server_url })
-
-  const checkHealth = () =>
-    dev_server_axios
-      .get("/api/health")
-      .then(() => true)
-      .catch((e) => false)
-
-  let is_dev_server_healthy = await checkHealth()
-
-  if (!is_dev_server_healthy) {
-    // attempt to use development-mode port, e.g. if someone ran
-    // npm run start:dev-server:dev
-    const devModeServerUrl = "http://127.0.0.1:3021"
-    dev_server_axios = getDevServerAxios({ serverUrl: devModeServerUrl })
-    is_dev_server_healthy = await checkHealth()
-    if (is_dev_server_healthy) server_url = devModeServerUrl
-  }
-
-  if (!is_dev_server_healthy) {
-    console.log(
-      kleur.red(
-        `Dev server doesn't seem to be running at ${server_url}. (Could not ping health)`,
-      ),
-    )
-    process.exit(1)
-  }
-
-  await fulfillExportRequests({ dev_server_axios }, ctx)
-}

package/cli/lib/cmd-fns/dev-server-upload.ts

@@ -1,56 +0,0 @@
-import kleur from "kleur"
-import { z } from "zod"
-import { AppContext } from "../util/app-context"
-import { getDevServerAxios } from "./dev/get-dev-server-axios"
-import { startFsWatcher } from "./dev/start-fs-watcher"
-import { uploadExamplesFromDirectory } from "./dev/upload-examples-from-directory"
-
-export const devServerUpload = async (ctx: AppContext, args: any) => {
-  const params = z
-    .object({
-      dir: z.string().optional().default(ctx.cwd),
-      port: z.coerce.number().optional().nullable().default(null),
-      watch: z.boolean().optional().default(false),
-    })
-    .parse(args)
-
-  let serverUrl = `http://127.0.0.1:${params.port ?? 3020}`
-  let devServerAxios = getDevServerAxios({ serverUrl })
-
-  const checkHealth = () =>
-    devServerAxios
-      .get("/api/health")
-      .then(() => true)
-      .catch((e) => false)
-
-  let is_dev_server_healthy = await checkHealth()
-
-  if (!is_dev_server_healthy && !params.port) {
-    // attempt to use development-mode port, e.g. if someone ran
-    // npm run start:dev-server:dev
-    const devModeServerUrl = "http://127.0.0.1:3021"
-    devServerAxios = getDevServerAxios({ serverUrl: devModeServerUrl })
-    is_dev_server_healthy = await checkHealth()
-    if (is_dev_server_healthy) serverUrl = devModeServerUrl
-  }
-
-  if (!is_dev_server_healthy) {
-    console.log(
-      kleur.red(
-        `Dev server doesn't seem to be running at ${serverUrl}. (Could not ping health)`,
-      ),
-    )
-    process.exit(1)
-  }
-
-  console.log(`Loading examples...`)
-  await uploadExamplesFromDirectory({ devServerAxios, cwd: params.dir }, ctx)
-
-  if (params.watch) {
-    // Start watcher
-    const watcher = await startFsWatcher(
-      { cwd: params.dir, devServerAxios },
-      ctx,
-    )
-  }
-}

package/cli/lib/cmd-fns/export-gerbers.ts

@@ -1,28 +0,0 @@
-import { AppContext } from "../util/app-context"
-import { z } from "zod"
-import { exportGerbersToFile } from "cli/lib/export-fns/export-gerbers"
-
-export const exportGerbersCmd = async (ctx: AppContext, args: any) => {
-  const params = z
-    .object({
-      file: z.string().optional(),
-      input: z.string().optional(),
-      export: z.string().optional(),
-      outputfile: z.string().optional().default("gerbers.zip"),
-    })
-    .refine((data) => data.file || data.input, {
-      message: "Either 'file' or 'input' must be provided",
-    })
-    .parse(args)
-
-  const inputFile = params.input || params.file
-
-  await exportGerbersToFile(
-    {
-      example_file_path: inputFile!,
-      export_name: params.export,
-      output_zip_path: params.outputfile,
-    },
-    ctx,
-  )
-}

package/cli/lib/cmd-fns/export-kicad-pcb.ts

@@ -1,36 +0,0 @@
-import { AppContext } from "../util/app-context"
-import { z } from "zod"
-import { soupify } from "cli/lib/soupify"
-import {
-  convertCircuitJsonToKiCadPcb,
-  convertKiCadPcbToSExprString,
-} from "kicad-converter"
-import fs from "fs/promises"
-import kleur from "kleur"
-
-export const exportKicadPcb = async (ctx: AppContext, args: any) => {
-  const params = z
-    .object({
-      input: z.string(),
-      export: z.string().optional(),
-      outputfile: z.string().default("output.kicad_pcb"),
-    })
-    .parse(args)
-
-  console.log(kleur.gray("[soupifying]..."))
-  const soup = await soupify(
-    {
-      filePath: params.input,
-      exportName: params.export,
-    },
-    ctx,
-  )
-
-  console.log(kleur.gray("[converting to KiCad PCB]..."))
-  const kicadPcb = convertCircuitJsonToKiCadPcb(soup)
-
-  console.log(kleur.gray(`[writing to ${params.outputfile}]...`))
-  await fs.writeFile(params.outputfile, convertKiCadPcbToSExprString(kicadPcb))
-
-  console.log(kleur.green(`KiCad PCB file exported to ${params.outputfile}`))
-}