@tscircuit/cli 0.0.206 → 0.0.208

package/.github/workflows/formatbot.yml

@@ -25,25 +25,25 @@ jobs:
       with:
         token: ${{ steps.check_fork.outputs.is_fork == 'true' && secrets.GITHUB_TOKEN || secrets.TSCIRCUIT_BOT_GITHUB_TOKEN }}
 
-    - name: Setup Node.js
-      uses: actions/setup-node@v3
+    - name: Setup bun
+      uses: oven-sh/setup-bun@v1
       with:
-        node-version: '20'
+        bun-version: latest
 
     - name: Get @biomejs/biome version
       id: get-biome-version
       run: echo "BIOME_VERSION=$(node -p "require('./package.json').devDependencies['@biomejs/biome']")" >> $GITHUB_OUTPUT
 
     - name: Install @biomejs/biome
-      run: npm install @biomejs/biome@${{ steps.get-biome-version.outputs.BIOME_VERSION }}
+      run: bun install
 
     - name: Run Formatter and autofix
       if: steps.check_fork.outputs.is_fork == 'false'
-      run: npx @biomejs/biome format . --write
+      run: bunx biome format . --write
 
     - name: Format Check (cannot autofix against forks)
       if: steps.check_fork.outputs.is_fork == 'true'
-      run: npx @biomejs/biome format .
+      run: bunx biome format .
 
     - name: Restore lock files
       if: steps.check_fork.outputs.is_fork == 'false'

package/.github/workflows/test.yml

@@ -29,4 +29,4 @@ jobs:
         run: bun run build
 
       - name: Run tests
-        run: bun test
+        run: bun test --timeout 15000

package/api/lib/zod/export_parameters.ts

@@ -5,6 +5,7 @@ export const export_parameters = z.object({
   should_export_pnp_csv: z.boolean().default(false),
   should_export_bom_csv: z.boolean().default(false),
   should_export_soup_json: z.boolean().default(false),
+  should_export_kicad_pcb: z.boolean().default(false),
   gerbers_zip_file_name: z
     .string()
     .nullable()
@@ -13,6 +14,11 @@ export const export_parameters = z.object({
   pnp_csv_file_name: z.string().nullable().optional().default("pnp.csv"),
   bom_csv_file_name: z.string().nullable().optional().default("bom.csv"),
   soup_json_file_name: z.string().nullable().optional().default("soup.json"),
+  kicad_pcb_file_name: z
+    .string()
+    .nullable()
+    .optional()
+    .default("output.kicad_pcb"),
 })
 
 export type ExportParametersInput = z.input<typeof export_parameters>

package/cli/lib/cmd-fns/dev/derive-selector-from-pcb-component-id.ts

@@ -1,4 +1,4 @@
-import type { AnySoupElement } from "@tscircuit/builder"
+import type { AnySoupElement } from "@tscircuit/soup"
 import { su } from "@tscircuit/soup-util"
 
 export const deriveSelectorFromPcbComponentId = ({
@@ -8,7 +8,7 @@ export const deriveSelectorFromPcbComponentId = ({
   soup: AnySoupElement[]
   pcb_component_id: string
 }) => {
-  const source_component = su(soup).source_component.getUsing({
+  const source_component = su(soup as any).source_component.getUsing({
     pcb_component_id,
   })
   if (!source_component) {

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

@@ -6,6 +6,7 @@ import { exportPnpCsvToBuffer } from "cli/lib/export-fns/export-pnp-csv"
 import { exportBomCsvToBuffer } from "cli/lib/export-fns/export-bom-csv"
 import { soupify } from "cli/lib/soupify"
 import { ExportRequest } from "api/db/schema"
+import { exportKicadPcbToBuffer } from "cli/lib/export-fns/export-kicad-pcb"
 
 export const uploadBufferToExportFile = async ({
   dev_server_axios,
@@ -139,5 +140,23 @@ export const fulfillExportRequests = async (
         export_request_id: export_request.export_request_id,
       })
     }
+
+    if (export_request.export_parameters.should_export_kicad_pcb) {
+      console.log(kleur.gray(`\n  exporting KiCad PCB...`))
+      const kicadPcbBuffer = await exportKicadPcbToBuffer(
+        {
+          example_file_path: export_request.example_file_path!,
+          export_name: export_request.export_name!,
+        },
+        ctx,
+      )
+
+      await uploadBufferToExportFile({
+        dev_server_axios,
+        file_buffer: kicadPcbBuffer,
+        file_name: export_request.export_parameters.kicad_pcb_file_name!,
+        export_request_id: export_request.export_request_id,
+      })
+    }
   }
 }

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

@@ -0,0 +1,36 @@
+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}`))
+}

package/cli/lib/cmd-fns/index.ts

@@ -38,6 +38,7 @@ export { configClear } from "./config-clear"
 export { openCmd as open } from "./open"
 export { versionCmd as version } from "./version"
 export { exportGerbersCmd as exportGerbers } from "./export-gerbers"
+export { exportKicadPcb } from "./export-kicad-pcb"
 export { devServerFulfillExportRequests } from "./dev-server-fulfill-export-requests"
 export { lintCmd as lint } from "./lint"
 export { renderCmd as render } from "./render"

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

@@ -0,0 +1,32 @@
+import { AppContext } from "../util/app-context"
+import { soupify } from "cli/lib/soupify"
+import {
+  convertCircuitJsonToKiCadPcb,
+  convertKiCadPcbToSExprString,
+} from "kicad-converter"
+import kleur from "kleur"
+
+export const exportKicadPcbToBuffer = async (
+  params: {
+    example_file_path: string
+    export_name?: string
+  },
+  ctx: AppContext,
+) => {
+  console.log(kleur.gray("[soupifying]..."))
+  const soup = await soupify(
+    {
+      filePath: params.example_file_path,
+      exportName: params.export_name,
+    },
+    ctx,
+  )
+
+  console.log(kleur.gray("[converting to KiCad PCB]..."))
+  const kicadPcb = convertCircuitJsonToKiCadPcb(soup)
+
+  console.log(kleur.gray("[converting to S-expression string]..."))
+  const kicadPcbString = convertKiCadPcbToSExprString(kicadPcb)
+
+  return Buffer.from(kicadPcbString, "utf-8")
+}

package/cli/lib/get-program.ts

@@ -293,6 +293,17 @@ export const getProgram = (ctx: AppContext) => {
     .option("--outputfile <outputfile>", "Output file name", "gerbers.zip")
     .action((args) => CMDFN.exportGerbers(ctx, args))
 
+  exportCmd
+    .command("kicad_pcb")
+    .description("Export KiCad PCB file from an example file")
+    .option("--input <input>", "Input example file")
+    .option(
+      "--export <export_name>",
+      "Name of export to soupify, if not specified, soupify the default/only export",
+    )
+    .option("--outputfile <outputfile>", "Output file name", "output.kicad_pcb")
+    .action((args) => CMDFN.exportKicadPcb(ctx, args))
+
   cmd
     .command("soupify")
     .description("Convert an example file to tscircuit soup")

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

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

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

@@ -10,6 +10,7 @@ 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")
 
@@ -25,7 +26,11 @@ export const soupifyWithCore = async (
   exportName ??= await getExportNameFromFile(filePath)
 
   const { tmpEntrypointPath, tmpOutputPath } =
-    getTmpEntrypointFilePath(filePath)
+    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(

package/cli/lib/soupify/soupify.ts

@@ -32,7 +32,7 @@ export const soupifyWithBuilder = async (
   exportName ??= await getExportNameFromFile(filePath)
 
   const { tmpEntrypointPath, tmpOutputPath } =
-    getTmpEntrypointFilePath(filePath)
+    await getTmpEntrypointFilePath(filePath)
 
   debug(`writing to ${tmpEntrypointPath}`)
   writeFileSync(

package/cli/tests/export-kicad-pcb.test.ts

@@ -0,0 +1,23 @@
+import { test, expect, describe } from "bun:test"
+import { $ } from "bun"
+import { temporaryDirectory } from "tempy"
+import { join } from "path"
+import { existsSync, readFileSync } from "fs"
+
+test("tsci export kicad_pcb --input example-project/examples/macrokeypad.tsx", async () => {
+  const tempDir = temporaryDirectory()
+  const kicadPcbPath = join(tempDir, "output.kicad_pcb")
+  const { stdout, stderr } =
+    await $`bun cli/cli.ts export kicad_pcb --input example-project/examples/macrokeypad.tsx --outputfile ${kicadPcbPath} --no-color`
+
+  expect(stderr.toString()).toBe("")
+  expect(stdout.toString()).toContain("output.kicad_pcb")
+
+  expect(existsSync(kicadPcbPath)).toBe(true)
+
+  const kicadPcbContent = readFileSync(kicadPcbPath, "utf-8")
+  expect(kicadPcbContent).toContain("(kicad_pcb")
+  expect(kicadPcbContent).toContain("(version")
+  expect(kicadPcbContent).toContain("(footprint")
+  expect(kicadPcbContent).toContain("(layer")
+})