sea-dev 1.0.0

package/apps/main/package.json

@@ -0,0 +1,131 @@
+{
+  "name": "@sea/main",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "script": "./dotenvx-safe.sh pnpm tsx",
+    "script:prd": "dotenvx run -- pnpm tsx",
+    "db:up": "docker compose -f ../../docker-compose.yml up -d postgres",
+    "db:down": "docker compose down",
+    "db:generate": "pnpm exec drizzle-kit generate",
+    "db:push:prd": "dotenvx run -- pnpm exec drizzle-kit push",
+    "db:migrate": "./dotenvx-safe.sh pnpm exec drizzle-kit migrate",
+    "db:migrate:prd": "dotenvx run -- pnpm exec drizzle-kit migrate",
+    "db:dev": "pnpm run db:up && sleep 1 && pnpm run db:migrate",
+    "repl": "pnpm run script ./scripts/repl.ts",
+    "db-test-cov": "tsx scripts/db-test-cov.ts",
+    "dev": "./dotenvx-safe.sh vite dev",
+    "dev:prd": "dotenvx run -- vite dev",
+    "logs": "tail -100 ./dev.log | sed 's/\\x1b\\[[0-9;]*m//g'",
+    "build": "vite build",
+    "start": "node .output/server/index.mjs",
+    "dev:start": "./dotenvx-safe.sh pnpm run start",
+    "dev:start:prd": "dotenvx run -- pnpm run start",
+    "fmt": "prettier --log-level warn --write .",
+    "lint": "eslint --fix . --ext .js,.jsx,.ts,.tsx",
+    "check": "tsc --noEmit",
+    "test": "IS_TEST=true vitest run",
+    "test:e2e": "playwright test",
+    "ci:fmt": "prettier --check .",
+    "ci:lint": "eslint . --ext .js,.jsx,.ts,.tsx",
+    "ci:check": "pnpm run check",
+    "ci:test": "pnpm run test",
+    "all": "pnpm run fmt && pnpm run lint && pnpm run check && pnpm run test",
+    "check-server": "curl -s -o /dev/null -w '%{http_code}' http://localhost:3000 | grep -q '^307$' && echo 'OK' || echo 'OFFLINE'"
+  },
+  "dependencies": {
+    "@ai-sdk/google": "^3.0.1",
+    "@ai-sdk/openai": "^3.0.1",
+    "@ai-sdk/react": "^3.0.3",
+    "@azure/storage-blob": "^12.27.0",
+    "@dnd-kit/core": "^6.3.1",
+    "@dnd-kit/sortable": "^10.0.0",
+    "@dnd-kit/utilities": "^3.2.2",
+    "@google/genai": "^1.34.0",
+    "@hatchet-dev/typescript-sdk": "^1.9.2",
+    "@polar-sh/sdk": "^0.34.9",
+    "@polar-sh/tanstack-start": "^0.1.5",
+    "@posthog/ai": "catalog:",
+    "@sea/ai": "workspace:*",
+    "@sea/cache": "workspace:*",
+    "@sea/clients": "workspace:*",
+    "@sea/config": "workspace:*",
+    "@sea/core": "workspace:*",
+    "@sea/dal": "workspace:*",
+    "@sea/db": "workspace:*",
+    "@sea/schemas": "workspace:*",
+    "@sea/ui": "workspace:*",
+    "@sea/util": "workspace:*",
+    "@tanstack/react-form": "^1.14.1",
+    "@tanstack/react-pacer": "^0.8.0",
+    "@tanstack/react-query": "^5.91.3",
+    "@tanstack/react-router": "^1.130.12",
+    "@tanstack/react-start": "^1.130.12",
+    "@tanstack/react-store": "^0.7.3",
+    "@tanstack/react-table": "^8.21.3",
+    "@tanstack/react-virtual": "^3.13.12",
+    "@vercel/sandbox": "^1.2.0",
+    "@xyflow/react": "^12.10.0",
+    "ai": "^6.0.3",
+    "better-auth": "^1.3.4",
+    "clsx": "^2.1.1",
+    "date-fns": "^4.1.0",
+    "drizzle-orm": "^0.43.1",
+    "exceljs": "^4.4.0",
+    "loops": "^5.0.1",
+    "lru-cache": "^11.1.0",
+    "lucide-react": "^0.503.0",
+    "nanoid": "^5.1.5",
+    "next-themes": "^0.4.6",
+    "openai": "^6.8.1",
+    "pdfjs-dist": "4.8.69",
+    "pino": "^9.9.0",
+    "pino-pretty": "^13.0.0",
+    "posthog-js": "catalog:",
+    "posthog-node": "catalog:",
+    "react": "^19.2.1",
+    "react-cookie": "^8.0.1",
+    "react-dom": "^19.2.1",
+    "react-intersection-observer": "^9.16.0",
+    "react-markdown": "^10.1.0",
+    "react-window": "^1.8.11",
+    "rehype-raw": "^7.0.0",
+    "remark-gfm": "^4.0.1",
+    "remeda": "^2.22.5",
+    "sonner": "^2.0.3",
+    "tailwind-merge": "^3.2.0",
+    "vite": "^7.1.2",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "@dotenvx/dotenvx": "^1.42.0",
+    "@electric-sql/pglite": "^0.3.14",
+    "@sea/lint": "workspace:*",
+    "@tailwindcss/postcss": "^4.1.5",
+    "@tailwindcss/typography": "^0.5.16",
+    "@testing-library/dom": "^10.4.0",
+    "@testing-library/react": "^16.2.0",
+    "@types/node": "^22.13.10",
+    "@types/pg": "*",
+    "@types/react": "^19.1.2",
+    "@types/react-dom": "^19.1.3",
+    "@types/react-window": "^1.8.8",
+    "@vitejs/plugin-react": "^4.6.0",
+    "drizzle-kit": "^0.30.5",
+    "jsdom": "^26.0.0",
+    "pg": "*",
+    "playwright": "^1.54.1",
+    "postcss": "^8.5.3",
+    "tailwindcss": "^4.1.5",
+    "ts-morph": "^26.0.0",
+    "tsx": "^4.19.3",
+    "tw-animate-css": "^1.2.8",
+    "vite-tsconfig-paths": "^5.1.4",
+    "vitest": "^3.0.8"
+  },
+  "engines": {
+    "node": ">=22.0.0 <23.0.0",
+    "pnpm": ">=10.13.0 <11.0.0"
+  },
+  "overrides": {}
+}

package/apps/main/playwright.config.ts

@@ -0,0 +1,23 @@
+import { defineConfig, devices } from "@playwright/test";
+
+import dotenv from "@dotenvx/dotenvx";
+dotenv.config();
+
+export default defineConfig({
+  testDir: "./e2e",
+  fullyParallel: true,
+  forbidOnly: !!process.env.CI,
+  retries: 0,
+  workers: process.env.CI ? 1 : undefined,
+  reporter: "html",
+  use: {
+    baseURL: "http://localhost:3000",
+    trace: "on-first-retry",
+  },
+  projects: [
+    {
+      name: "chromium",
+      use: { ...devices["Desktop Chrome"] },
+    },
+  ],
+});

package/apps/main/postcss.config.ts

@@ -0,0 +1,5 @@
+export default {
+  plugins: {
+    "@tailwindcss/postcss": {},
+  },
+};

package/apps/main/public/bg-dark.svg

@@ -0,0 +1,10 @@
+<svg width="100%" height="100%" viewBox="0 0 1440 800" xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="none">
+  <rect width="100%" height="100%" fill="black" />
+  <path d="M0,100 C360,50 1080,150 1440,100" stroke="#0077be" stroke-width="2.5" fill="none" />
+  <path d="M0,200 C240,250 720,150 1440,200" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.9"/>
+  <path d="M0,300 C180,200 960,400 1440,300" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.8"/>
+  <path d="M0,400 C320,500 1120,300 1440,400" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.7"/>
+  <path d="M0,500 C400,350 1040,650 1440,500" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.6"/>
+  <path d="M0,600 C200,700 1240,500 1440,600" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.5"/>
+  <path d="M0,700 C280,600 1160,800 1440,700" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.4"/>
+</svg>

package/apps/main/public/bg.svg

@@ -0,0 +1,10 @@
+<svg width="100%" height="100%" viewBox="0 0 1440 800" xmlns="http://www.w3.org/2000/svg" preserveAspectRatio="none">
+  <rect width="100%" height="100%" fill="white" />
+  <path d="M0,100 C360,50 1080,150 1440,100" stroke="#0077be" stroke-width="2.5" fill="none" />
+  <path d="M0,200 C240,250 720,150 1440,200" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.9"/>
+  <path d="M0,300 C180,200 960,400 1440,300" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.8"/>
+  <path d="M0,400 C320,500 1120,300 1440,400" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.7"/>
+  <path d="M0,500 C400,350 1040,650 1440,500" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.6"/>
+  <path d="M0,600 C200,700 1240,500 1440,600" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.5"/>
+  <path d="M0,700 C280,600 1160,800 1440,700" stroke="#0077be" stroke-width="2.5" fill="none" opacity="0.4"/>
+</svg>

package/apps/main/run.sh

@@ -0,0 +1,146 @@
+#!/bin/bash
+
+# I got this from:
+# https://gist.github.com/mitsuhiko/8ca80fda0bf48045d54bcd34d76ad887
+
+# [shoreman](https://github.com/chrismytton/shoreman) is an
+# implementation of the **Procfile** format. Inspired by the original
+# [foreman](http://ddollar.github.com/foreman/) tool for ruby.
+
+# Make sure that any errors cause the script to exit immediately.
+set -eo pipefail
+[[ "$TRACE" ]] && set -x
+
+# ## Usage
+
+# Usage message that is displayed when `--help` is given as an argument.
+usage() {
+  echo "Usage: shoreman [procfile|Procfile]"
+  echo "Run Procfiles using shell."
+  echo
+  echo "The shoreman script reads commands from [procfile] and starts up the"
+  echo "processes that it describes."
+}
+
+# ## Logging
+
+# For logging we want to prefix each entry with the current time, as well
+# as the process name. This takes two arguments, the name of the process
+# with its index, and then reads data from stdin, formats it, and sends it
+# to stdout and dev.log.
+log() {
+  local index="$2"
+  local format="%s %s\t| %s"
+  local log_format="%s %s\t| %s"
+
+  # We add colors when output is a terminal. `SHOREMAN_COLORS` can override it.
+  if [ -t 1 -o "$SHOREMAN_COLORS" == "always" ] \
+     && [ "$SHOREMAN_COLORS" != "never" ]; then
+    # Bash colors start from 31 up to 37. We calculate what color the process
+    # gets based on its index.
+    local color="$((31 + (index % 7)))"
+    format="\033[0;${color}m%s %s\t|\033[0m %s"
+  fi
+
+  while IFS= read -r data
+  do
+    local timestamp="$(date +"%H:%M:%S")"
+    printf "$format\n" "$timestamp" "$1" "$data"
+    printf "$log_format\n" "$timestamp" "$1" "$data" >> dev.log
+  done
+}
+
+# ## Running commands
+
+# When a process is started, we want to keep track of its pid so we can
+# `kill` it when the parent process receives a signal, and so we can `wait`
+# for it to finish before exiting the parent process.
+store_pid() {
+  pids="$pids $1"
+}
+
+# This starts a command asynchronously and stores its pid in a list for use
+# later on in the script.
+start_command() {
+  bash -c "$1" 2>&1 | log "$2" "$3" &
+  pid="$(jobs -p %%)"
+  store_pid "$pid"
+}
+
+# ## Reading the Procfile
+
+# The Procfile needs to be parsed to extract the process names and commands.
+# The file is given on stdin, see the `<` at the end of this while loop.
+run_procfile() {
+  local procfile=${1:-'Procfile'}
+  # We give each process an index to track its color. We start with 1,
+  # because it corresponds to green which is easier on the eye than red (0).
+  local index=1
+  while read line || [[ -n "$line" ]]; do
+    if [[ -z "$line" ]] || [[ "$line" == \#* ]]; then continue; fi
+    local name="${line%%:*}"
+    local command="${line#*:[[:space:]]}"
+    start_command "$command" "${name}" "$index"
+    echo "'${command}' started with pid $pid" | log "${name}" "$index"
+    index=$((index + 1))
+  done < "$procfile"
+}
+
+# ## Cleanup
+
+# When a `SIGINT`, `SIGTERM` or `EXIT` is received, this action is run, killing the
+# child processes. The sleep stops STDOUT from pouring over the prompt, it
+# should probably go at some point.
+onexit() {
+  echo "SIGINT received" > /dev/stderr
+  echo "sending SIGTERM to all processes" > /dev/stderr
+  echo "$(date +"%H:%M:%S") PROCESS MANAGER SHUTTING DOWN" >> dev.log
+  kill $pids 2> /dev/null
+  # Remove PID file on exit
+  rm -f ".shoreman.pid"
+  sleep 1
+}
+
+main() {
+  local procfile="$1"
+  local pidfile=".shoreman.pid"
+
+  # If the `--help` option is given, show the usage message and exit.
+  expr -- "$*" : ".*--help" >/dev/null && {
+    usage
+    exit 0
+  }
+
+  # Check if shoreman is already running
+  if [[ -f "$pidfile" ]]; then
+    local existing_pid=$(cat "$pidfile")
+    if kill -0 "$existing_pid" 2>/dev/null; then
+      echo "error: services are already running" >&2
+      exit 1
+    fi
+    # PID file exists but process is not running, remove stale PID file
+    rm -f "$pidfile"
+  fi
+
+  # Write our PID to the PID file
+  echo $$ > "$pidfile"
+
+  echo "=================================================================" >> dev.log
+  echo "$(date +"%H:%M:%S") PROCESS MANAGER STARTED" >> dev.log
+  echo "=================================================================" >> dev.log
+  
+  run_procfile "$procfile"
+
+  trap onexit INT TERM
+
+  exitcode=0
+  for pid in $pids; do
+      # Wait for the children to finish executing before exiting.
+      wait "${pid}" 2> /dev/null || exitcode=$?
+  done
+  # Remove PID file on normal exit
+  rm -f "$pidfile"
+  exit $exitcode
+}
+
+main "$@"

package/apps/main/scripts/browser.ts

@@ -0,0 +1,14 @@
+import { chromium } from "playwright";
+
+// Example simple Browser automation
+(async () => {
+  const browser = await chromium.launch({ headless: false });
+  const page = await browser.newPage();
+
+  await page.goto("https://example.com");
+
+  const bodyContent = await page.locator("body").innerHTML();
+  console.log(bodyContent);
+
+  await browser.close();
+})();

package/apps/main/scripts/db-test-cov.ts

@@ -0,0 +1,277 @@
+#!/usr/bin/env tsx
+import * as fs from "fs";
+import * as path from "path";
+import { Node, Project, SyntaxKind } from "ts-morph";
+import { fileURLToPath } from "url";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = path.dirname(__filename);
+
+const OUTPUT_FILE = "db-tests.jsonl";
+
+// Types for our results
+interface DbUsage {
+  path: string;
+  function: string;
+  exported: boolean;
+  wrapped: boolean;
+  tested: boolean;
+}
+
+// Initialize the project
+const project = new Project({
+  tsConfigFilePath: path.join(__dirname, "..", "tsconfig.json"),
+});
+
+// Get all source files (excluding tests and generated files)
+const sourceFiles = project.getSourceFiles().filter((sf) => {
+  const filePath = sf.getFilePath();
+  return (
+    !filePath.includes("node_modules") &&
+    !filePath.includes(".test.") &&
+    !filePath.includes(".gen.") &&
+    !filePath.endsWith(".d.ts")
+  );
+});
+
+// Track all db usages
+const dbUsages: DbUsage[] = [];
+
+// Helper to get the containing function name and check if it's in a createServerFn and if it's exported
+function getContainingFunctionInfo(node: Node): {
+  name: string | null;
+  isServerFn: boolean;
+  isExported: boolean;
+} {
+  let current: Node | undefined = node;
+  let functionName: string | null = null;
+  let isServerFn = false;
+  let isExported = false;
+  let foundFunction = false;
+
+  while (current && !foundFunction) {
+    if (Node.isFunctionDeclaration(current)) {
+      functionName = current.getName() || null;
+      foundFunction = true;
+      // Check if function declaration is exported
+      isExported = current.isExported();
+    } else if (Node.isMethodDeclaration(current)) {
+      functionName = current.getName() || null;
+      foundFunction = true;
+      // Methods in exported classes/objects are considered exported
+      const classOrObj =
+        current.getFirstAncestorByKind(SyntaxKind.ClassDeclaration) ||
+        current.getFirstAncestorByKind(SyntaxKind.ObjectLiteralExpression);
+      if (classOrObj && Node.isClassDeclaration(classOrObj)) {
+        isExported = classOrObj.isExported();
+      }
+    } else if (Node.isFunctionExpression(current) || Node.isArrowFunction(current)) {
+      // Check if it's assigned to a variable
+      const parent = current.getParent();
+      if (Node.isVariableDeclaration(parent)) {
+        functionName = parent.getName();
+        foundFunction = true;
+        // Check if the variable is exported
+        const varStatement = parent.getFirstAncestorByKind(SyntaxKind.VariableStatement);
+        if (varStatement) {
+          isExported = varStatement.isExported();
+        }
+      } else if (Node.isPropertyAssignment(parent)) {
+        functionName = parent.getName();
+        foundFunction = true;
+        // Check if the containing object is exported
+        const objLiteral = parent.getFirstAncestorByKind(SyntaxKind.ObjectLiteralExpression);
+        if (objLiteral) {
+          const varDecl = objLiteral.getFirstAncestorByKind(SyntaxKind.VariableDeclaration);
+          if (varDecl) {
+            const varStatement = varDecl.getFirstAncestorByKind(SyntaxKind.VariableStatement);
+            if (varStatement) {
+              isExported = varStatement.isExported();
+            }
+          }
+        }
+      } else if (Node.isCallExpression(parent)) {
+        // Check for patterns like: export const foo = createServerFn(async () => {})
+        const grandParent = parent.getParent();
+        if (Node.isVariableDeclaration(grandParent)) {
+          functionName = grandParent.getName();
+          foundFunction = true;
+          const varStatement = grandParent.getFirstAncestorByKind(SyntaxKind.VariableStatement);
+          if (varStatement) {
+            isExported = varStatement.isExported();
+          }
+        }
+      }
+    }
+    current = current.getParent();
+  }
+
+  // Now check if this function is defined within a createServerFn or createServerFileRoute chain
+  if (functionName) {
+    const sourceFile = node.getSourceFile();
+
+    // First check if it's a variable declaration (like createDealFn)
+    const varDecl = sourceFile.getVariableDeclaration(functionName);
+
+    if (varDecl) {
+      const initializer = varDecl.getInitializer();
+      if (initializer && Node.isCallExpression(initializer)) {
+        // Check if this is a createServerFn or createServerFileRoute call chain
+        let callExpr: Node | undefined = initializer;
+        while (callExpr && Node.isCallExpression(callExpr)) {
+          const expr = callExpr.getExpression();
+          const exprText = expr.getText();
+          if (exprText.includes("createServerFn") || exprText.includes("createServerFileRoute")) {
+            isServerFn = true;
+            break;
+          }
+          // Check for chained calls like createServerFn().middleware().handler()
+          if (Node.isPropertyAccessExpression(expr)) {
+            callExpr = expr.getExpression();
+          } else {
+            break;
+          }
+        }
+      }
+    } else {
+      // Check if it's a method within a createServerFileRoute methods object
+      // Walk up to find if we're in a createServerFileRoute call
+      let ancestor = node.getParent();
+      while (ancestor) {
+        if (Node.isCallExpression(ancestor)) {
+          const expr = ancestor.getExpression();
+          if (expr.getText().includes("createServerFileRoute")) {
+            isServerFn = true;
+            break;
+          }
+        }
+        ancestor = ancestor.getParent();
+      }
+    }
+  }
+
+  return { name: functionName, isServerFn, isExported };
+}
+
+// Helper to check if a test exists for a function
+function hasTestForFunction(filePath: string, functionName: string): boolean {
+  // Convert source file path to test file path
+  const dir = path.dirname(filePath);
+  const baseName = path.basename(filePath, ".ts").replace(".tsx", "");
+  const testPath = path.join(dir, `${baseName}.test.ts`);
+
+  if (!fs.existsSync(testPath)) {
+    return false;
+  }
+
+  try {
+    const testContent = fs.readFileSync(testPath, "utf-8");
+    // Look for describe("dbtest: functionName")
+    const testPattern = new RegExp(
+      `describe\\s*\\(\\s*["'\`]dbtest:\\s*${functionName}["'\`]`,
+      "i",
+    );
+    return testPattern.test(testContent);
+  } catch {
+    return false;
+  }
+}
+
+// Process each source file
+for (const sourceFile of sourceFiles) {
+  const filePath = sourceFile.getFilePath();
+
+  // Find imports of db from @sea/db
+  const imports = sourceFile.getImportDeclarations();
+  let dbIdentifier: string | null = null;
+
+  for (const imp of imports) {
+    if (imp.getModuleSpecifierValue() === "@sea/db") {
+      // Check for named imports
+      const namedImports = imp.getNamedImports();
+      for (const namedImport of namedImports) {
+        if (namedImport.getName() === "db") {
+          dbIdentifier = namedImport.getAliasNode()?.getText() || "db";
+          break;
+        }
+      }
+
+      // Check for namespace imports (import * as seaDb from "@sea/db")
+      const namespaceImport = imp.getNamespaceImport();
+      if (namespaceImport) {
+        // We'll need to look for seaDb.db usage
+        dbIdentifier = namespaceImport.getText() + ".db";
+      }
+    }
+  }
+
+  if (!dbIdentifier) {
+    continue;
+  }
+
+  // Find all references to db
+  const identifiers = sourceFile.getDescendantsOfKind(SyntaxKind.Identifier);
+
+  for (const identifier of identifiers) {
+    const text = identifier.getText();
+
+    // Check if this is our db identifier
+    if (
+      text === dbIdentifier ||
+      (dbIdentifier.includes(".") && identifier.getParent()?.getText() === dbIdentifier)
+    ) {
+      // Skip if it's part of the import statement
+      if (identifier.getFirstAncestorByKind(SyntaxKind.ImportDeclaration)) {
+        continue;
+      }
+
+      const functionInfo = getContainingFunctionInfo(identifier);
+      if (functionInfo.name) {
+        const hasTest = hasTestForFunction(filePath, functionInfo.name);
+        const relativePath = path.relative(process.cwd(), filePath);
+
+        // Check if we already have this function recorded
+        const existing = dbUsages.find(
+          (u) => u.path === relativePath && u.function === functionInfo.name,
+        );
+
+        if (!existing) {
+          dbUsages.push({
+            path: relativePath,
+            function: functionInfo.name,
+            exported: functionInfo.isExported,
+            wrapped: functionInfo.isServerFn,
+            tested: hasTest,
+          });
+        }
+      }
+    }
+  }
+}
+
+// Sort results by file and function name
+dbUsages.sort((a, b) => {
+  const fileCompare = a.path.localeCompare(b.path);
+  if (fileCompare !== 0) return fileCompare;
+  return a.function.localeCompare(b.function);
+});
+
+// Write results to JSONL file
+const outputPath = path.join(__dirname, "..", OUTPUT_FILE);
+const jsonlContent = dbUsages.map((usage) => JSON.stringify(usage)).join("\n");
+fs.writeFileSync(outputPath, jsonlContent + "\n");
+
+// Calculate statistics
+const wrappedCount = dbUsages.filter((u) => u.wrapped).length;
+const testableCount = dbUsages.filter((u) => u.exported && !u.wrapped).length;
+const testedCount = dbUsages.filter((u) => u.exported && !u.wrapped && u.tested).length;
+const untestedExportedCount = dbUsages.filter((u) => u.exported && !u.wrapped && !u.tested).length;
+
+// Print summary
+console.log(`\nDatabase Test Coverage Analysis Complete\n`);
+console.log(`Total functions using db: ${dbUsages.length}`);
+console.log(`  - Wrapped (createServerFn/createServerFileRoute): ${wrappedCount}`);
+console.log(`  - Testable: ${testableCount}`);
+console.log(`  - Tested: ${testedCount}`);
+console.log(`  - Untested testable: ${untestedExportedCount}`);
+console.log(`\nResults written to: ${outputPath}`);