@tscircuit/cli 0.1.496 → 0.1.497

package/dist/main.js

@@ -72387,7 +72387,7 @@ var getGlobalDepsInstallCommand = (packageManager, deps) => {
 import { execSync as execSync2 } from "node:child_process";
 var import_semver2 = __toESM2(require_semver2(), 1);
 // package.json
-var version = "0.1.495";
+var version = "0.1.496";
 var package_default = {
   name: "@tscircuit/cli",
   version,
@@ -92912,6 +92912,9 @@ var KicadPcb = class _KicadPcb extends SxClass {
   }
 };
 SxClass.register(KicadPcb);
+var parseKicadSexpr = (sexpr) => {
+  return SxClass.parse(sexpr);
+};
 
 // node_modules/circuit-json-to-kicad/dist/index.js
 import { cju } from "@tscircuit/circuit-json-util";
@@ -195882,8 +195885,8 @@ var registerRemove = (program3) => {
 };
 
 // cli/build/register.ts
-import path33 from "node:path";
-import fs34 from "node:fs";
+import path35 from "node:path";
+import fs36 from "node:fs";
 
 // cli/build/build-file.ts
 import path29 from "node:path";
@@ -195938,13 +195941,16 @@ var buildFile = async (input, output, projectDir, options) => {
     }
     if (errors.length > 0 && !options?.ignoreErrors) {
       console.error(kleur_default.red(`Build failed with ${errors.length} error(s). Use --ignore-errors to continue.`));
-      return false;
+      return { ok: false };
     } else {
-      return true;
+      return {
+        ok: true,
+        circuitJson: result.circuitJson
+      };
     }
   } catch (err) {
     console.error(`Build failed: ${err}`);
-    return false;
+    return { ok: false };
   }
 };
 
@@ -196157,9 +196163,167 @@ var buildPreviewImages = async ({
   });
 };
 
-// cli/build/transpile.ts
-import path32 from "node:path";
+// cli/build/generate-kicad-project.ts
 import fs33 from "node:fs";
+import path32 from "node:path";
+var createKicadProContent = ({
+  projectName,
+  schematicFileName,
+  boardFileName
+}) => JSON.stringify({
+  head: {
+    version: 1,
+    generator: "tsci"
+  },
+  project: {
+    name: projectName,
+    files: {
+      schematic: schematicFileName,
+      board: boardFileName
+    }
+  }
+}, null, 2);
+var generateKicadProject = async ({
+  circuitJson,
+  outputDir,
+  projectName,
+  writeFiles
+}) => {
+  const schConverter = new CircuitJsonToKicadSchConverter(circuitJson);
+  schConverter.runUntilFinished();
+  const schContent = schConverter.getOutputString();
+  const pcbConverter = new CircuitJsonToKicadPcbConverter(circuitJson);
+  pcbConverter.runUntilFinished();
+  const pcbContent = pcbConverter.getOutputString();
+  const sanitizedProjectName = projectName.trim().length > 0 ? projectName.trim() : "project";
+  const schematicFileName = `${sanitizedProjectName}.kicad_sch`;
+  const boardFileName = `${sanitizedProjectName}.kicad_pcb`;
+  const projectFileName = `${sanitizedProjectName}.kicad_pro`;
+  const proContent = createKicadProContent({
+    projectName: sanitizedProjectName,
+    schematicFileName,
+    boardFileName
+  });
+  if (writeFiles) {
+    fs33.mkdirSync(outputDir, { recursive: true });
+    fs33.writeFileSync(path32.join(outputDir, schematicFileName), schContent);
+    fs33.writeFileSync(path32.join(outputDir, boardFileName), pcbContent);
+    fs33.writeFileSync(path32.join(outputDir, projectFileName), proContent);
+  }
+  return {
+    pcbContent,
+    schContent,
+    proContent,
+    outputDir,
+    projectName: sanitizedProjectName
+  };
+};
+
+// cli/build/generate-kicad-footprint-library.ts
+import fs34 from "node:fs";
+import path33 from "node:path";
+var sanitizeLibraryAndFootprintName = (libraryLink) => {
+  if (!libraryLink) {
+    return {
+      libraryName: "generated",
+      footprintName: "footprint"
+    };
+  }
+  if (!libraryLink.includes(":")) {
+    return {
+      libraryName: "generated",
+      footprintName: libraryLink.replace(/[\\\/]/g, "-") || "footprint"
+    };
+  }
+  const [rawLibraryName, rawFootprintName] = libraryLink.split(":", 2);
+  const libraryName = rawLibraryName?.replace(/[\\\/]/g, "-").trim() || "generated";
+  const footprintName = rawFootprintName?.replace(/[\\\/]/g, "-").trim() || "footprint";
+  return {
+    libraryName,
+    footprintName
+  };
+};
+var sanitizeFootprint = (footprint) => {
+  const { libraryName, footprintName } = sanitizeLibraryAndFootprintName(footprint.libraryLink);
+  footprint.libraryLink = footprintName;
+  footprint.position = At.from([0, 0, 0]);
+  footprint.locked = false;
+  footprint.placed = false;
+  footprint.uuid = undefined;
+  footprint.path = undefined;
+  footprint.sheetfile = undefined;
+  footprint.sheetname = undefined;
+  footprint.properties = [];
+  const texts = footprint.fpTexts ?? [];
+  for (const text of texts) {
+    text.uuid = undefined;
+    if (text.type === "reference") {
+      text.text = "REF**";
+    } else if (text.type === "value" && text.text.trim().length === 0) {
+      text.text = footprintName;
+    }
+  }
+  footprint.fpTexts = texts;
+  const pads = footprint.fpPads ?? [];
+  for (const pad2 of pads) {
+    pad2.uuid = undefined;
+    pad2.net = undefined;
+  }
+  footprint.fpPads = pads;
+  return {
+    libraryName,
+    footprintName,
+    content: footprint.getString()
+  };
+};
+var generateKicadFootprintLibrary = async ({
+  projects,
+  distDir
+}) => {
+  const libraryRoot = path33.join(distDir, "kicad-footprints");
+  fs34.mkdirSync(libraryRoot, { recursive: true });
+  const uniqueFootprints = new Map;
+  for (const project of projects) {
+    try {
+      const parsed = parseKicadSexpr(project.pcbContent);
+      const pcb = parsed.find((node) => node instanceof KicadPcb);
+      if (!pcb)
+        continue;
+      const footprints = pcb.footprints ?? [];
+      for (const footprint of footprints) {
+        const sanitized = sanitizeFootprint(footprint);
+        const key = `${sanitized.libraryName}::${sanitized.footprintName}`;
+        if (!uniqueFootprints.has(key)) {
+          uniqueFootprints.set(key, sanitized);
+        }
+      }
+    } catch (error) {
+      console.warn(`Failed to parse KiCad PCB content for footprint extraction from ${project.sourcePath}:`, error);
+    }
+  }
+  const libraryNames = new Set;
+  for (const entry of uniqueFootprints.values()) {
+    libraryNames.add(entry.libraryName);
+    const libraryDir = path33.join(libraryRoot, `${entry.libraryName}.pretty`);
+    fs34.mkdirSync(libraryDir, { recursive: true });
+    const footprintPath = path33.join(libraryDir, `${entry.footprintName}.kicad_mod`);
+    fs34.writeFileSync(footprintPath, `${entry.content}
+`);
+  }
+  if (libraryNames.size > 0) {
+    const libTableEntries = Array.from(libraryNames).sort().map((name) => `  (lib (name ${name}) (type KiCad) (uri \${KIPRJMOD}/kicad-footprints/${name}.pretty) (options "") (descr "Generated by tsci build"))`);
+    const libTableContent = `(fp_lib_table
+${libTableEntries.join(`
+`)}
+)
+`;
+    fs34.writeFileSync(path33.join(libraryRoot, "fp-lib-table"), libTableContent);
+  }
+};
+
+// cli/build/transpile.ts
+import path34 from "node:path";
+import fs35 from "node:fs";
 import { rollup } from "rollup";
 import typescript from "@rollup/plugin-typescript";
 import resolve11 from "@rollup/plugin-node-resolve";
@@ -196172,7 +196336,7 @@ var transpileFile = async ({
   projectDir
 }) => {
   try {
-    fs33.mkdirSync(outputDir, { recursive: true });
+    fs35.mkdirSync(outputDir, { recursive: true });
     console.log("Building ESM bundle...");
     const esmBundle = await rollup({
       input,
@@ -196202,11 +196366,11 @@ var transpileFile = async ({
       ]
     });
     await esmBundle.write({
-      file: path32.join(outputDir, "index.js"),
+      file: path34.join(outputDir, "index.js"),
       format: "es",
       sourcemap: false
     });
-    console.log(`ESM bundle written to ${path32.relative(projectDir, path32.join(outputDir, "index.js"))}`);
+    console.log(`ESM bundle written to ${path34.relative(projectDir, path34.join(outputDir, "index.js"))}`);
     console.log("Building CommonJS bundle...");
     const cjsBundle = await rollup({
       input,
@@ -196236,11 +196400,11 @@ var transpileFile = async ({
       ]
     });
     await cjsBundle.write({
-      file: path32.join(outputDir, "index.cjs"),
+      file: path34.join(outputDir, "index.cjs"),
       format: "cjs",
       sourcemap: false
     });
-    console.log(`CommonJS bundle written to ${path32.relative(projectDir, path32.join(outputDir, "index.cjs"))}`);
+    console.log(`CommonJS bundle written to ${path34.relative(projectDir, path34.join(outputDir, "index.cjs"))}`);
     console.log("Generating type declarations...");
     const dtsBundle = await rollup({
       input,
@@ -196260,8 +196424,8 @@ var transpileFile = async ({
     dtsContent = dtsContent.replace(/import \* as [\w_]+ from ['"]react\/jsx-runtime['"];?\s*\n?/g, "");
     dtsContent = dtsContent.replace(/[\w_]+\.JSX\.Element/g, "any");
     dtsContent = dtsContent.replace(/export\s*{\s*};\s*$/gm, "").trim();
-    fs33.writeFileSync(path32.join(outputDir, "index.d.ts"), dtsContent);
-    console.log(`Type declarations written to ${path32.relative(projectDir, path32.join(outputDir, "index.d.ts"))}`);
+    fs35.writeFileSync(path34.join(outputDir, "index.d.ts"), dtsContent);
+    console.log(`Type declarations written to ${path34.relative(projectDir, path34.join(outputDir, "index.d.ts"))}`);
     console.log(kleur_default.green("Transpilation complete!"));
     return true;
   } catch (err) {
@@ -196275,7 +196439,7 @@ var transpileFile = async ({
 
 // cli/build/register.ts
 var registerBuild = (program3) => {
-  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").option("--disable-pcb", "Disable PCB outputs").option("--disable-parts-engine", "Disable the parts engine").option("--site", "Generate a static site in the dist directory").option("--transpile", "Transpile the entry file to JavaScript").option("--preview-images", "Generate preview images in the dist directory").option("--all-images", "Generate preview images for every successful build output").action(async (file, options) => {
+  program3.command("build").description("Run tscircuit eval and output circuit json").argument("[file]", "Path to the entry file").option("--ignore-errors", "Do not exit with code 1 on errors").option("--ignore-warnings", "Do not log warnings").option("--disable-pcb", "Disable PCB outputs").option("--disable-parts-engine", "Disable the parts engine").option("--site", "Generate a static site in the dist directory").option("--transpile", "Transpile the entry file to JavaScript").option("--preview-images", "Generate preview images in the dist directory").option("--all-images", "Generate preview images for every successful build output").option("--kicad", "Generate KiCad project directories for each successful build output").option("--kicad-footprint-library", "Generate a KiCad footprint library from all successful build outputs").action(async (file, options) => {
     try {
       const { projectDir, circuitFiles, mainEntrypoint } = await getBuildEntrypoints({
         fileOrDir: file
@@ -196292,18 +196456,20 @@ var registerBuild = (program3) => {
         }
         return config;
       })();
-      const distDir = path33.join(projectDir, "dist");
-      fs34.mkdirSync(distDir, { recursive: true });
+      const distDir = path35.join(projectDir, "dist");
+      fs36.mkdirSync(distDir, { recursive: true });
       console.log(`Building ${circuitFiles.length} file(s)...`);
       let hasErrors = false;
       const staticFileReferences = [];
       const builtFiles = [];
+      const kicadProjects = [];
+      const shouldGenerateKicad = options?.kicad || options?.kicadFootprintLibrary;
       for (const filePath of circuitFiles) {
-        const relative9 = path33.relative(projectDir, filePath);
+        const relative9 = path35.relative(projectDir, filePath);
         console.log(`Building ${relative9}...`);
         const outputDirName = relative9.replace(/(\.board|\.circuit)?\.tsx$/, "");
-        const outputPath = path33.join(distDir, outputDirName, "circuit.json");
-        const ok = await buildFile(filePath, outputPath, projectDir, {
+        const outputPath = path35.join(distDir, outputDirName, "circuit.json");
+        const buildOutcome = await buildFile(filePath, outputPath, projectDir, {
           ignoreErrors: options?.ignoreErrors,
           ignoreWarnings: options?.ignoreWarnings,
           platformConfig: platformConfig2
@@ -196311,19 +196477,33 @@ var registerBuild = (program3) => {
         builtFiles.push({
           sourcePath: filePath,
           outputPath,
-          ok
+          ok: buildOutcome.ok
         });
-        if (!ok) {
+        if (!buildOutcome.ok) {
           hasErrors = true;
         } else if (options?.site) {
-          const normalizedSourcePath = relative9.split(path33.sep).join("/");
-          const relativeOutputPath = path33.join(outputDirName, "circuit.json");
-          const normalizedOutputPath = relativeOutputPath.split(path33.sep).join("/");
+          const normalizedSourcePath = relative9.split(path35.sep).join("/");
+          const relativeOutputPath = path35.join(outputDirName, "circuit.json");
+          const normalizedOutputPath = relativeOutputPath.split(path35.sep).join("/");
           staticFileReferences.push({
             filePath: normalizedSourcePath,
             fileStaticAssetUrl: `./${normalizedOutputPath}`
           });
         }
+        if (buildOutcome.ok && shouldGenerateKicad && buildOutcome.circuitJson) {
+          const projectOutputDir = path35.join(distDir, outputDirName, "kicad");
+          const projectName = path35.basename(outputDirName);
+          const project = await generateKicadProject({
+            circuitJson: buildOutcome.circuitJson,
+            outputDir: projectOutputDir,
+            projectName,
+            writeFiles: Boolean(options?.kicad)
+          });
+          kicadProjects.push({
+            ...project,
+            sourcePath: filePath
+          });
+        }
       }
       if (hasErrors && !options?.ignoreErrors) {
         process.exit(1);
@@ -196360,8 +196540,18 @@ var registerBuild = (program3) => {
           files: staticFileReferences,
           standaloneScriptSrc: "./standalone.min.js"
         });
-        fs34.writeFileSync(path33.join(distDir, "index.html"), indexHtml);
-        fs34.writeFileSync(path33.join(distDir, "standalone.min.js"), standalone_min_default);
+        fs36.writeFileSync(path35.join(distDir, "index.html"), indexHtml);
+        fs36.writeFileSync(path35.join(distDir, "standalone.min.js"), standalone_min_default);
+      }
+      if (options?.kicadFootprintLibrary) {
+        if (kicadProjects.length === 0) {
+          console.warn("No successful build output available for KiCad footprint library generation.");
+        } else {
+          await generateKicadFootprintLibrary({
+            projects: kicadProjects,
+            distDir
+          });
+        }
       }
       console.log("Build complete!");
       process.exit(0);
@@ -196374,8 +196564,8 @@ var registerBuild = (program3) => {
 };
 
 // lib/shared/snapshot-project.ts
-import fs36 from "node:fs";
-import path34 from "node:path";
+import fs38 from "node:fs";
+import path36 from "node:path";
 import looksSame2 from "looks-same";
 import {
   convertCircuitJsonToPcbSvg as convertCircuitJsonToPcbSvg3,
@@ -196386,7 +196576,7 @@ import { renderGLTFToPNGBufferFromGLBBuffer as renderGLTFToPNGBufferFromGLBBuffe
 
 // lib/shared/compare-images.ts
 import looksSame from "looks-same";
-import fs35 from "node:fs/promises";
+import fs37 from "node:fs/promises";
 var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
   const { equal: equal2 } = await looksSame(buffer1, buffer2, {
     strict: false,
@@ -196402,7 +196592,7 @@ var compareAndCreateDiff = async (buffer1, buffer2, diffPath) => {
         tolerance: 2
       });
     } else {
-      await fs35.writeFile(diffPath, buffer2);
+      await fs37.writeFile(diffPath, buffer2);
     }
   }
   return { equal: equal2 };
@@ -196427,7 +196617,7 @@ var snapshotProject = async ({
     ...DEFAULT_IGNORED_PATTERNS,
     ...ignored.map(normalizeIgnorePattern)
   ];
-  const resolvedPaths = filePaths.map((f) => path34.resolve(projectDir, f));
+  const resolvedPaths = filePaths.map((f) => path36.resolve(projectDir, f));
   const boardFiles = findBoardFiles({
     projectDir,
     ignore,
@@ -196441,7 +196631,7 @@ var snapshotProject = async ({
   const mismatches = [];
   let didUpdate = false;
   for (const file of boardFiles) {
-    const relativeFilePath = path34.relative(projectDir, file);
+    const relativeFilePath = path36.relative(projectDir, file);
     let circuitJson;
     let pcbSvg;
     let schSvg;
@@ -196495,17 +196685,17 @@ var snapshotProject = async ({
       } catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         if (errorMessage.includes("No pcb_board found in circuit JSON")) {
-          const fileDir = path34.dirname(file);
-          const relativeDir = path34.relative(projectDir, fileDir);
-          const snapDir2 = snapshotsDirName ? path34.join(projectDir, snapshotsDirName, relativeDir) : path34.join(fileDir, "__snapshots__");
-          const base2 = path34.basename(file).replace(/\.tsx$/, "");
-          const snap3dPath = path34.join(snapDir2, `${base2}-3d.snap.png`);
-          const existing3dSnapshot = fs36.existsSync(snap3dPath);
+          const fileDir = path36.dirname(file);
+          const relativeDir = path36.relative(projectDir, fileDir);
+          const snapDir2 = snapshotsDirName ? path36.join(projectDir, snapshotsDirName, relativeDir) : path36.join(fileDir, "__snapshots__");
+          const base2 = path36.basename(file).replace(/\.tsx$/, "");
+          const snap3dPath = path36.join(snapDir2, `${base2}-3d.snap.png`);
+          const existing3dSnapshot = fs38.existsSync(snap3dPath);
           if (existing3dSnapshot) {
             onError(kleur_default.red(`
 ❌ Failed to generate 3D snapshot for ${relativeFilePath}:
 `) + kleur_default.red(`   No pcb_board found in circuit JSON
-`) + kleur_default.red(`   Existing snapshot: ${path34.relative(projectDir, snap3dPath)}
+`) + kleur_default.red(`   Existing snapshot: ${path36.relative(projectDir, snap3dPath)}
 `));
             return onExit(1);
           } else {
@@ -196521,9 +196711,9 @@ var snapshotProject = async ({
         }
       }
     }
-    const snapDir = snapshotsDirName ? path34.join(projectDir, snapshotsDirName, path34.relative(projectDir, path34.dirname(file))) : path34.join(path34.dirname(file), "__snapshots__");
-    fs36.mkdirSync(snapDir, { recursive: true });
-    const base = path34.basename(file).replace(/\.tsx$/, "");
+    const snapDir = snapshotsDirName ? path36.join(projectDir, snapshotsDirName, path36.relative(projectDir, path36.dirname(file))) : path36.join(path36.dirname(file), "__snapshots__");
+    fs38.mkdirSync(snapDir, { recursive: true });
+    const base = path36.basename(file).replace(/\.tsx$/, "");
     const snapshots = [];
     if (pcbOnly || !schematicOnly) {
       snapshots.push({ type: "pcb", content: pcbSvg, isBinary: false });
@@ -196541,31 +196731,31 @@ var snapshotProject = async ({
     for (const snapshot of snapshots) {
       const { type } = snapshot;
       const is3d = type === "3d";
-      const snapPath = path34.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
-      const existing = fs36.existsSync(snapPath);
+      const snapPath = path36.join(snapDir, `${base}-${type}.snap.${is3d ? "png" : "svg"}`);
+      const existing = fs38.existsSync(snapPath);
       const newContentBuffer = snapshot.isBinary ? snapshot.content : Buffer.from(snapshot.content, "utf8");
       const newContentForFile = snapshot.content;
       if (!existing) {
-        fs36.writeFileSync(snapPath, newContentForFile);
-        console.log("✅", kleur_default.gray(path34.relative(projectDir, snapPath)));
+        fs38.writeFileSync(snapPath, newContentForFile);
+        console.log("✅", kleur_default.gray(path36.relative(projectDir, snapPath)));
         didUpdate = true;
         continue;
       }
-      const oldContentBuffer = fs36.readFileSync(snapPath);
+      const oldContentBuffer = fs38.readFileSync(snapPath);
       const diffPath = snapPath.replace(is3d ? ".snap.png" : ".snap.svg", is3d ? ".diff.png" : ".diff.svg");
       const { equal: equal2 } = await compareAndCreateDiff(oldContentBuffer, newContentBuffer, diffPath);
       if (update) {
         if (!forceUpdate && equal2) {
-          console.log("✅", kleur_default.gray(path34.relative(projectDir, snapPath)));
+          console.log("✅", kleur_default.gray(path36.relative(projectDir, snapPath)));
         } else {
-          fs36.writeFileSync(snapPath, newContentForFile);
-          console.log("✅", kleur_default.gray(path34.relative(projectDir, snapPath)));
+          fs38.writeFileSync(snapPath, newContentForFile);
+          console.log("✅", kleur_default.gray(path36.relative(projectDir, snapPath)));
           didUpdate = true;
         }
       } else if (!equal2) {
         mismatches.push(`${snapPath} (diff: ${diffPath})`);
       } else {
-        console.log("✅", kleur_default.gray(path34.relative(projectDir, snapPath)));
+        console.log("✅", kleur_default.gray(path36.relative(projectDir, snapPath)));
       }
     }
   }
@@ -196604,22 +196794,22 @@ var registerSnapshot = (program3) => {
 };
 
 // lib/shared/setup-github-actions.ts
-import fs37 from "node:fs";
-import path35 from "node:path";
+import fs39 from "node:fs";
+import path37 from "node:path";
 var setupGithubActions = (projectDir = process.cwd()) => {
   const findGitRoot = (startDir) => {
-    let dir = path35.resolve(startDir);
-    while (dir !== path35.parse(dir).root) {
-      if (fs37.existsSync(path35.join(dir, ".git"))) {
+    let dir = path37.resolve(startDir);
+    while (dir !== path37.parse(dir).root) {
+      if (fs39.existsSync(path37.join(dir, ".git"))) {
         return dir;
       }
-      dir = path35.dirname(dir);
+      dir = path37.dirname(dir);
     }
     return null;
   };
   const gitRoot = findGitRoot(projectDir) ?? projectDir;
-  const workflowsDir = path35.join(gitRoot, ".github", "workflows");
-  fs37.mkdirSync(workflowsDir, { recursive: true });
+  const workflowsDir = path37.join(gitRoot, ".github", "workflows");
+  fs39.mkdirSync(workflowsDir, { recursive: true });
   const buildWorkflow = `name: tscircuit Build
 
 on:
@@ -196658,8 +196848,8 @@ jobs:
       - run: bun install
       - run: bunx tsci snapshot
 `;
-  writeFileIfNotExists(path35.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
-  writeFileIfNotExists(path35.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
+  writeFileIfNotExists(path37.join(workflowsDir, "tscircuit-build.yml"), buildWorkflow);
+  writeFileIfNotExists(path37.join(workflowsDir, "tscircuit-snapshot.yml"), snapshotWorkflow);
 };
 
 // cli/setup/register.ts
@@ -196685,8 +196875,8 @@ var registerSetup = (program3) => {
 };
 
 // cli/convert/register.ts
-import fs38 from "node:fs/promises";
-import path36 from "node:path";
+import fs40 from "node:fs/promises";
+import path38 from "node:path";
 import { parseKicadModToCircuitJson } from "kicad-component-converter";
 
 // node_modules/@tscircuit/mm/dist/index.js
@@ -196806,15 +196996,15 @@ var convertCircuitJsonToTscircuit = (circuitJson, opts) => {
 var registerConvert = (program3) => {
   program3.command("convert").description("Convert a .kicad_mod footprint to a tscircuit component").argument("<file>", "Path to the .kicad_mod file").option("-o, --output <path>", "Output TSX file path").option("-n, --name <component>", "Component name for export").action(async (file, options) => {
     try {
-      const inputPath = path36.resolve(file);
-      const modContent = await fs38.readFile(inputPath, "utf-8");
+      const inputPath = path38.resolve(file);
+      const modContent = await fs40.readFile(inputPath, "utf-8");
       const circuitJson = await parseKicadModToCircuitJson(modContent);
-      const componentName = options.name ?? path36.basename(inputPath, ".kicad_mod");
+      const componentName = options.name ?? path38.basename(inputPath, ".kicad_mod");
       const tsx = convertCircuitJsonToTscircuit(circuitJson, {
         componentName
       });
-      const outputPath = options.output ? path36.resolve(options.output) : path36.join(path36.dirname(inputPath), `${componentName}.tsx`);
-      await fs38.writeFile(outputPath, tsx);
+      const outputPath = options.output ? path38.resolve(options.output) : path38.join(path38.dirname(inputPath), `${componentName}.tsx`);
+      await fs40.writeFile(outputPath, tsx);
       console.log(kleur_default.green(`Converted ${outputPath}`));
     } catch (error) {
       console.error(kleur_default.red("Failed to convert footprint:"), error instanceof Error ? error.message : error);
@@ -196909,12 +197099,12 @@ var registerSimulate = (program3) => {
 };
 
 // lib/shared/install-project-dependencies.ts
-import fs40 from "node:fs";
-import path38 from "node:path";
+import fs42 from "node:fs";
+import path40 from "node:path";
 
 // lib/shared/collect-tsci-dependencies.ts
-import fs39 from "node:fs";
-import path37 from "node:path";
+import fs41 from "node:fs";
+import path39 from "node:path";
 var DEFAULT_PATTERNS = ["**/*.{ts,tsx,js,jsx}"];
 var DEFAULT_IGNORES = [
   "**/node_modules/**",
@@ -196929,7 +197119,7 @@ function collectTsciDependencies({
   patterns = DEFAULT_PATTERNS,
   ignore = DEFAULT_IGNORES
 } = {}) {
-  const searchRoot = path37.resolve(cwd);
+  const searchRoot = path39.resolve(cwd);
   const files = globbySync(patterns, {
     cwd: searchRoot,
     absolute: true,
@@ -196939,7 +197129,7 @@ function collectTsciDependencies({
   const dependencies2 = new Set;
   for (const filePath of files) {
     try {
-      const fileContents = fs39.readFileSync(filePath, "utf-8");
+      const fileContents = fs41.readFileSync(filePath, "utf-8");
       let match;
       while (true) {
         match = IMPORT_PATTERN.exec(fileContents);
@@ -196956,26 +197146,26 @@ function collectTsciDependencies({
 async function installProjectDependencies({
   cwd = process.cwd()
 } = {}) {
-  const projectRoot = path38.resolve(cwd);
-  const packageJsonPath = path38.join(projectRoot, "package.json");
-  const npmrcPath = path38.join(projectRoot, ".npmrc");
+  const projectRoot = path40.resolve(cwd);
+  const packageJsonPath = path40.join(projectRoot, "package.json");
+  const npmrcPath = path40.join(projectRoot, ".npmrc");
   const packageManager = getPackageManager();
-  if (!fs40.existsSync(projectRoot)) {
+  if (!fs42.existsSync(projectRoot)) {
     throw new Error(`Directory not found: ${projectRoot}`);
   }
   let packageJsonCreated = false;
-  if (!fs40.existsSync(packageJsonPath)) {
+  if (!fs42.existsSync(packageJsonPath)) {
     console.log("No package.json found. Generating a new one.");
     generatePackageJson(projectRoot);
     packageJsonCreated = true;
   } else {
     console.log("Found existing package.json.");
   }
-  if (!fs40.existsSync(npmrcPath)) {
+  if (!fs42.existsSync(npmrcPath)) {
     console.log("Creating .npmrc with tscircuit registry configuration.");
-    fs40.writeFileSync(npmrcPath, "@tsci:registry=https://npm.tscircuit.com");
+    fs42.writeFileSync(npmrcPath, "@tsci:registry=https://npm.tscircuit.com");
   }
-  const packageJson = JSON.parse(fs40.readFileSync(packageJsonPath, "utf-8"));
+  const packageJson = JSON.parse(fs42.readFileSync(packageJsonPath, "utf-8"));
   if (packageJsonCreated) {
     const tsciDependencies = collectTsciDependencies({ cwd: projectRoot });
     if (tsciDependencies.length > 0) {
@@ -196990,7 +197180,7 @@ async function installProjectDependencies({
       console.log("No @tsci dependencies detected in circuit files.");
     }
   }
-  fs40.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
+  fs42.writeFileSync(packageJsonPath, `${JSON.stringify(packageJson, null, 2)}
 `);
   console.log(`Installing dependencies using ${kleur_default.bold(packageManager.name)}...`);
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tscircuit/cli",
-  "version": "0.1.496",
+  "version": "0.1.497",
   "main": "dist/main.js",
   "devDependencies": {
     "@babel/standalone": "^7.26.9",