diff --git a/.gitignore b/.gitignore
index 62f195a..b9fdc42 100644
--- a/.gitignore
+++ b/.gitignore
@@ -174,4 +174,6 @@ dist
 # Finder (MacOS) folder config
 .DS_Store
 
-.vscode
\ No newline at end of file
+.vscode
+.aider*
+package-lock.json
\ No newline at end of file
diff --git a/biome.json b/biome.json
new file mode 100644
index 0000000..8249be5
--- /dev/null
+++ b/biome.json
@@ -0,0 +1,49 @@
+{
+  "$schema": "https://biomejs.dev/schemas/1.9.3/schema.json",
+  "organizeImports": {
+    "enabled": true
+  },
+  "formatter": {
+    "enabled": true,
+    "indentStyle": "space"
+  },
+  "files": {
+    "ignore": ["cosmos-export", "dist", "package.json"]
+  },
+  "javascript": {
+    "formatter": {
+      "jsxQuoteStyle": "double",
+      "quoteProperties": "asNeeded",
+      "trailingCommas": "all",
+      "semicolons": "asNeeded",
+      "arrowParentheses": "always",
+      "bracketSpacing": true,
+      "bracketSameLine": false
+    }
+  },
+  "linter": {
+    "enabled": true,
+    "rules": {
+      "recommended": true,
+      "suspicious": {
+        "noExplicitAny": "off"
+      },
+      "complexity": {
+        "noForEach": "info"
+      },
+      "style": {
+        "noUselessElse": "off",
+        "noNonNullAssertion": "off",
+        "useNumberNamespace": "off",
+        "useFilenamingConvention": {
+          "level": "error",
+          "options": {
+            "strictCase": true,
+            "requireAscii": true,
+            "filenameCases": ["kebab-case", "export"]
+          }
+        }
+      }
+    }
+  }
+}
diff --git a/bun.lockb b/bun.lockb
index 784445f..64f1781 100755
Binary files a/bun.lockb and b/bun.lockb differ
diff --git a/cli/main.ts b/cli/main.ts
index e69de29..3dcda7c 100644
--- a/cli/main.ts
+++ b/cli/main.ts
@@ -0,0 +1,79 @@
+#!/usr/bin/env node
+import { Command } from "commander"
+import * as path from "path"
+import * as chokidar from "chokidar"
+import * as fs from "fs"
+import { createServer } from "../lib/server/createServer"
+import { getLocalFileDependencies } from "../lib/dependency-analysis/getLocalFileDependencies"
+
+const program = new Command()
+
+program
+  .name("snippets")
+  .description("CLI for developing tscircuit snippets")
+  .version("1.0.0")
+
+program
+  .command("dev")
+  .description("Start development server for a snippet")
+  .argument("<file>", "Path to the snippet file")
+  .option("-p, --port <number>", "Port to run server on", "3000")
+  .action(async (file: string, options: { port: string }) => {
+    const absolutePath = path.resolve(file)
+    const port = parseInt(options.port)
+
+    // Start the server
+    await createServer(port)
+
+    // Function to update file content
+    const updateFile = async (filePath: string) => {
+      try {
+        const content = await fs.promises.readFile(filePath, "utf-8")
+        const response = await fetch(
+          `http://localhost:${port}/api/files/upsert`,
+          {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+              file_path: path.relative(process.cwd(), filePath),
+              text_content: content,
+            }),
+          },
+        )
+        if (!response.ok) {
+          console.error(`Failed to update ${filePath}`)
+        }
+      } catch (error) {
+        console.error(`Error updating ${filePath}:`, error)
+      }
+    }
+
+    // Get initial dependencies
+    let dependencies = new Set([absolutePath])
+    try {
+      const deps = getLocalFileDependencies(absolutePath)
+      deps.forEach((dep) => dependencies.add(dep))
+    } catch (error) {
+      console.warn("Failed to analyze dependencies:", error)
+    }
+
+    // Watch the main file and its dependencies
+    const watcher = chokidar.watch(Array.from(dependencies), {
+      persistent: true,
+      ignoreInitial: false,
+    })
+
+    watcher.on("change", async (filePath) => {
+      console.log(`File ${filePath} changed`)
+      await updateFile(filePath)
+    })
+
+    watcher.on("add", async (filePath) => {
+      console.log(`File ${filePath} added`)
+      await updateFile(filePath)
+    })
+
+    console.log(`Watching ${file} and its dependencies...`)
+  })
+
+program.parse()
diff --git a/example-dir/snippet.tsx b/example-dir/snippet.tsx
new file mode 100644
index 0000000..83df69b
--- /dev/null
+++ b/example-dir/snippet.tsx
@@ -0,0 +1,18 @@
+import { useRedLed } from "@tsci/seveibar.red-led"
+import { usePushButton } from "@tsci/seveibar.push-button"
+import { useUsbC } from "@tsci/seveibar.smd-usb-c"
+
+export default () => {
+  const USBC = useUsbC("USBC")
+  const Button = usePushButton("SW1")
+  const Led = useRedLed("LED")
+  return (
+    <board width="12mm" height="30mm" schAutoLayoutEnabled>
+      <USBC GND="net.GND" pcbY={-10} VBUS1="net.VBUS" />
+      <Led neg="net.GND" pcbY={12} />
+      <Button pcbY={0} pin2=".R1 > .pos" pin3="net.VBUS" />
+      <resistor name="R1" footprint="0603" resistance="1k" pcbY={7} />
+      <trace from=".R1 > .neg" to={Led.pos} />
+    </board>
+  )
+}
diff --git a/lib/dependency-analysis/DependencyAnalyzer.ts b/lib/dependency-analysis/DependencyAnalyzer.ts
index f22bff4..ccf3851 100644
--- a/lib/dependency-analysis/DependencyAnalyzer.ts
+++ b/lib/dependency-analysis/DependencyAnalyzer.ts
@@ -1,127 +1,129 @@
-import * as ts from 'typescript';
-import * as path from 'path';
-import * as fs from 'fs';
+import * as ts from "typescript"
+import * as path from "path"
+import * as fs from "fs"
 
 interface DependencyAnalyzerOptions {
-  baseDir: string;
-  includeNodeModules?: boolean;
-  includeCssModules?: boolean;
+  baseDir: string
+  includeNodeModules?: boolean
+  includeCssModules?: boolean
 }
 
 class DependencyAnalyzer {
-  private readonly baseDir: string;
-  private readonly includeNodeModules: boolean;
-  private readonly includeCssModules: boolean;
-  private readonly cache: Map<string, Set<string>> = new Map();
+  private readonly baseDir: string
+  private readonly includeNodeModules: boolean
+  private readonly includeCssModules: boolean
+  private readonly cache: Map<string, Set<string>> = new Map()
 
   constructor(options: DependencyAnalyzerOptions) {
-    this.baseDir = options.baseDir;
-    this.includeNodeModules = options.includeNodeModules ?? false;
-    this.includeCssModules = options.includeCssModules ?? true;
+    this.baseDir = options.baseDir
+    this.includeNodeModules = options.includeNodeModules ?? false
+    this.includeCssModules = options.includeCssModules ?? true
   }
 
   public analyze(filePath: string): Set<string> {
     if (this.cache.has(filePath)) {
-      return this.cache.get(filePath)!;
+      return this.cache.get(filePath)!
     }
 
-    const dependencies = new Set<string>();
-    const sourceFile = this.createSourceFile(filePath);
+    const dependencies = new Set<string>()
+    const sourceFile = this.createSourceFile(filePath)
 
     if (!sourceFile) {
-      return dependencies;
+      return dependencies
     }
 
-    this.visitNode(sourceFile, dependencies);
-    this.cache.set(filePath, dependencies);
+    this.visitNode(sourceFile, dependencies)
+    this.cache.set(filePath, dependencies)
 
-    return dependencies;
+    return dependencies
   }
 
   private createSourceFile(filePath: string): ts.SourceFile | null {
     try {
-      const content = fs.readFileSync(filePath, 'utf-8');
+      const content = fs.readFileSync(filePath, "utf-8")
       return ts.createSourceFile(
         filePath,
         content,
         ts.ScriptTarget.Latest,
-        true
-      );
+        true,
+      )
     } catch (error) {
-      console.error(`Error reading file ${filePath}:`, error);
-      return null;
+      console.error(`Error reading file ${filePath}:`, error)
+      return null
     }
   }
 
   private visitNode(node: ts.Node, dependencies: Set<string>): void {
     if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
-      const moduleSpecifier = node.moduleSpecifier;
+      const moduleSpecifier = node.moduleSpecifier
       if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
-        const importPath = moduleSpecifier.text;
-        this.addDependency(importPath, dependencies);
+        const importPath = moduleSpecifier.text
+        this.addDependency(importPath, dependencies)
       }
     }
 
     // Check for dynamic imports
-    if (ts.isCallExpression(node) && 
-        node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-      const argument = node.arguments[0];
+    if (
+      ts.isCallExpression(node) &&
+      node.expression.kind === ts.SyntaxKind.ImportKeyword
+    ) {
+      const argument = node.arguments[0]
       if (argument && ts.isStringLiteral(argument)) {
-        this.addDependency(argument.text, dependencies);
+        this.addDependency(argument.text, dependencies)
       }
     }
 
-    ts.forEachChild(node, child => this.visitNode(child, dependencies));
+    ts.forEachChild(node, (child) => this.visitNode(child, dependencies))
   }
 
   private addDependency(importPath: string, dependencies: Set<string>): void {
     // Skip node_modules unless explicitly included
-    if (!this.includeNodeModules && importPath.startsWith('node_modules')) {
-      return;
+    if (!this.includeNodeModules && importPath.startsWith("node_modules")) {
+      return
     }
 
     // Handle CSS modules if enabled
-    if (this.includeCssModules && importPath.endsWith('.css')) {
-      const resolvedPath = this.resolvePath(importPath);
+    if (this.includeCssModules && importPath.endsWith(".css")) {
+      const resolvedPath = this.resolvePath(importPath)
       if (resolvedPath) {
-        dependencies.add(resolvedPath);
+        dependencies.add(resolvedPath)
       }
-      return;
+      return
     }
 
     // Resolve relative imports
-    if (importPath.startsWith('.')) {
-      const resolvedPath = this.resolvePath(importPath);
+    if (importPath.startsWith(".")) {
+      const resolvedPath = this.resolvePath(importPath)
       if (resolvedPath) {
-        dependencies.add(resolvedPath);
+        dependencies.add(resolvedPath)
       }
     }
   }
 
   private resolvePath(importPath: string): string | null {
     try {
-      const extensions = ['.tsx', '.ts', '.jsx', '.js', '.css'];
-      const resolvedPath = path.resolve(this.baseDir, importPath);
+      const extensions = [".tsx", ".ts", ".jsx", ".js", ".css"]
+      const resolvedPath = path.resolve(this.baseDir, importPath)
 
       // Try exact path first
       if (fs.existsSync(resolvedPath)) {
-        return resolvedPath;
+        return resolvedPath
       }
 
       // Try with extensions
       for (const ext of extensions) {
-        const pathWithExt = resolvedPath + ext;
+        const pathWithExt = resolvedPath + ext
         if (fs.existsSync(pathWithExt)) {
-          return pathWithExt;
+          return pathWithExt
         }
       }
 
-      return null;
+      return null
     } catch (error) {
-      console.error(`Error resolving path ${importPath}:`, error);
-      return null;
+      console.error(`Error resolving path ${importPath}:`, error)
+      return null
     }
   }
 }
 
-export { DependencyAnalyzer, type DependencyAnalyzerOptions };
\ No newline at end of file
+export { DependencyAnalyzer, type DependencyAnalyzerOptions }
diff --git a/lib/dependency-analysis/getLocalFileDependencies.ts b/lib/dependency-analysis/getLocalFileDependencies.ts
index 16d8c65..b4a0273 100644
--- a/lib/dependency-analysis/getLocalFileDependencies.ts
+++ b/lib/dependency-analysis/getLocalFileDependencies.ts
@@ -1,87 +1,101 @@
-import * as ts from 'typescript';
-import * as path from 'path';
-import * as fs from 'fs';
+import * as ts from "typescript"
+import * as path from "path"
+import * as fs from "fs"
 
 function getLocalFileDependencies(pathToTsxFile: string): string[] {
-    // Ensure absolute path
-    const absolutePath = path.resolve(pathToTsxFile);
-    const baseDir = path.dirname(absolutePath);
-    
-    // Read and parse the file
-    const content = fs.readFileSync(absolutePath, 'utf-8');
-    const sourceFile = ts.createSourceFile(
-        absolutePath,
-        content,
-        ts.ScriptTarget.Latest,
-        true
-    );
+  // Ensure absolute path
+  const absolutePath = path.resolve(pathToTsxFile)
+  const baseDir = path.dirname(absolutePath)
 
-    const dependencies = new Set<string>();
+  // Read and parse the file
+  const content = fs.readFileSync(absolutePath, "utf-8")
+  const sourceFile = ts.createSourceFile(
+    absolutePath,
+    content,
+    ts.ScriptTarget.Latest,
+    true,
+  )
 
-    // Recursively visit nodes to find imports
-    function visit(node: ts.Node) {
-        if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
-            const moduleSpecifier = node.moduleSpecifier;
-            if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
-                const importPath = moduleSpecifier.text;
-                // Only process local imports (starting with . or ..)
-                if (importPath.startsWith('.')) {
-                    resolveAndAddDependency(importPath);
-                }
-            }
-        }
+  const dependencies = new Set<string>()
 
-        // Handle dynamic imports
-        if (ts.isCallExpression(node) && 
-            node.expression.kind === ts.SyntaxKind.ImportKeyword) {
-            const argument = node.arguments[0];
-            if (argument && ts.isStringLiteral(argument)) {
-                const importPath = argument.text;
-                if (importPath.startsWith('.')) {
-                    resolveAndAddDependency(importPath);
-                }
-            }
+  // Recursively visit nodes to find imports
+  function visit(node: ts.Node) {
+    if (ts.isImportDeclaration(node) || ts.isExportDeclaration(node)) {
+      const moduleSpecifier = node.moduleSpecifier
+      if (moduleSpecifier && ts.isStringLiteral(moduleSpecifier)) {
+        const importPath = moduleSpecifier.text
+        // Only process local imports (starting with . or ..)
+        if (importPath.startsWith(".")) {
+          resolveAndAddDependency(importPath)
         }
+      }
+    }
 
-        ts.forEachChild(node, visit);
+    // Handle dynamic imports
+    if (
+      ts.isCallExpression(node) &&
+      node.expression.kind === ts.SyntaxKind.ImportKeyword
+    ) {
+      const argument = node.arguments[0]
+      if (argument && ts.isStringLiteral(argument)) {
+        const importPath = argument.text
+        if (importPath.startsWith(".")) {
+          resolveAndAddDependency(importPath)
+        }
+      }
     }
 
-    // Helper to resolve and add dependency paths
-    function resolveAndAddDependency(importPath: string) {
-        const extensions = ['.tsx', '.ts', '.jsx', '.js', '.css', '.scss', '.sass', '.less'];
-        let resolvedPath = path.resolve(baseDir, importPath);
+    ts.forEachChild(node, visit)
+  }
 
-        // Check if path exists as-is
-        if (fs.existsSync(resolvedPath)) {
-            dependencies.add(resolvedPath);
-            return;
-        }
+  // Helper to resolve and add dependency paths
+  function resolveAndAddDependency(importPath: string) {
+    const extensions = [
+      ".tsx",
+      ".ts",
+      ".jsx",
+      ".js",
+      ".css",
+      ".scss",
+      ".sass",
+      ".less",
+    ]
+    let resolvedPath = path.resolve(baseDir, importPath)
 
-        // Try with extensions
-        for (const ext of extensions) {
-            const pathWithExt = resolvedPath + ext;
-            if (fs.existsSync(pathWithExt)) {
-                dependencies.add(pathWithExt);
-                return;
-            }
-        }
+    // Check if path exists as-is
+    if (fs.existsSync(resolvedPath)) {
+      dependencies.add(resolvedPath)
+      return
+    }
+
+    // Try with extensions
+    for (const ext of extensions) {
+      const pathWithExt = resolvedPath + ext
+      if (fs.existsSync(pathWithExt)) {
+        dependencies.add(pathWithExt)
+        return
+      }
+    }
 
-        // Check for index files in directories
-        if (fs.existsSync(resolvedPath) && fs.statSync(resolvedPath).isDirectory()) {
-            for (const ext of extensions) {
-                const indexPath = path.join(resolvedPath, `index${ext}`);
-                if (fs.existsSync(indexPath)) {
-                    dependencies.add(indexPath);
-                    return;
-                }
-            }
+    // Check for index files in directories
+    if (
+      fs.existsSync(resolvedPath) &&
+      fs.statSync(resolvedPath).isDirectory()
+    ) {
+      for (const ext of extensions) {
+        const indexPath = path.join(resolvedPath, `index${ext}`)
+        if (fs.existsSync(indexPath)) {
+          dependencies.add(indexPath)
+          return
         }
+      }
     }
+  }
 
-    // Start the traversal
-    visit(sourceFile);
+  // Start the traversal
+  visit(sourceFile)
 
-    return Array.from(dependencies);
+  return Array.from(dependencies)
 }
 
-export { getLocalFileDependencies };
\ No newline at end of file
+export { getLocalFileDependencies }
diff --git a/lib/index.ts b/lib/index.ts
index e69de29..0453d4c 100644
--- a/lib/index.ts
+++ b/lib/index.ts
@@ -0,0 +1,2 @@
+export { createServer } from "./server/createServer"
+export { getLocalFileDependencies } from "./dependency-analysis/getLocalFileDependencies"
diff --git a/lib/server/createServer.ts b/lib/server/createServer.ts
new file mode 100644
index 0000000..022f0ae
--- /dev/null
+++ b/lib/server/createServer.ts
@@ -0,0 +1,34 @@
+import * as http from "http"
+import { getNodeHandler } from "winterspec/adapters/node"
+import winterspecBundle from "@tscircuit/file-server/dist/bundle"
+import { getIndex } from "../site/getIndex"
+
+export const createServer = async (port: number = 3000) => {
+  const fileServerHandler = getNodeHandler(winterspecBundle as any, {})
+
+  const server = http.createServer(async (req, res) => {
+    if (req.url === "/") {
+      console.log("getting index")
+      const html = await getIndex()
+      res.writeHead(200, { "Content-Type": "text/html" })
+      res.end(html)
+      return
+    }
+
+    if (req.url?.startsWith("/api/")) {
+      req.url = req.url.replace("/api/", "/")
+      fileServerHandler(req, res)
+      return
+    }
+
+    res.writeHead(404)
+    res.end("Not found")
+  })
+
+  return new Promise<void>((resolve) => {
+    server.listen(port, () => {
+      console.log(`Server running at http://localhost:${port}`)
+      resolve()
+    })
+  })
+}
diff --git a/package.json b/package.json
index 7b9e8b7..88baa28 100644
--- a/package.json
+++ b/package.json
@@ -2,7 +2,13 @@
   "name": "@tscircuit/snippets-cli",
   "main": "dist/lib/index.js",
   "type": "module",
+  "scripts": {
+    "dev": "bun run cli/main.ts dev ./example-dir/snippet.tsx",
+    "format": "biome format --write .",
+    "format:check": "biome format ."
+  },
   "devDependencies": {
+    "@biomejs/biome": "^1.9.4",
     "@types/bun": "latest",
     "@types/configstore": "^6.0.2",
     "tsup": "^8.3.5"
@@ -12,6 +18,7 @@
   },
   "dependencies": {
     "@tscircuit/file-server": "^0.0.5",
+    "chokidar": "^4.0.1",
     "commander": "^12.1.0",
     "configstore": "^7.0.0"
   }