@tscircuit/cli 0.0.206 → 0.0.207

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/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/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")
+})