npm - spfn - Versions diffs - 0.2.0-beta.21 → 0.2.0-beta.23 - Mend

spfn 0.2.0-beta.21 → 0.2.0-beta.23

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (2) hide show

package/dist/index.js +659 -344
package/package.json +3 -3

package/dist/index.js CHANGED Viewed

@@ -755,7 +755,7 @@ var init_deployment_config = __esm({
 // src/utils/version.ts
 function getCliVersion() {
-  return "0.2.0-beta.21";
+  return "0.2.0-beta.23";
 }
 function getTagFromVersion(version) {
   const match = version.match(/-([a-z]+)\./i);
@@ -1042,7 +1042,7 @@ __export(function_migrations_exports, {
   discoverFunctionMigrations: () => discoverFunctionMigrations,
   executeFunctionMigrations: () => executeFunctionMigrations
 });
-import chalk11 from "chalk";
+import chalk12 from "chalk";
 import { join as join15 } from "path";
 import { env as env2 } from "@spfn/core/config";
 import { loadEnv as loadEnv2 } from "@spfn/core/server";
@@ -1073,7 +1073,7 @@ function discoverFunctionMigrations(cwd = process.cwd()) {
       const migrationsDir = join15(packagePath, spfnConfig.migrations.dir);
       if (!existsSync16(migrationsDir)) {
         console.warn(
-          chalk11.yellow(`\u26A0\uFE0F  Package @spfn/${pkg} specifies migrations but directory not found: ${migrationsDir}`)
+          chalk12.yellow(`\u26A0\uFE0F  Package @spfn/${pkg} specifies migrations but directory not found: ${migrationsDir}`)
         );
         continue;
       }
@@ -1083,7 +1083,7 @@ function discoverFunctionMigrations(cwd = process.cwd()) {
         packagePath
       });
     } catch (error) {
-      console.warn(chalk11.yellow(`\u26A0\uFE0F  Failed to parse package.json for @spfn/${pkg}`));
+      console.warn(chalk12.yellow(`\u26A0\uFE0F  Failed to parse package.json for @spfn/${pkg}`));
     }
   }
   return functions;
@@ -1101,13 +1101,13 @@ async function executeFunctionMigrations(functionMigrations) {
   const db = drizzle(connection);
   try {
     for (const func of functionMigrations) {
-      console.log(chalk11.blue(`
+      console.log(chalk12.blue(`
   \u{1F4E6} Running ${func.packageName} migrations...`));
       await migrate(db, {
         migrationsFolder: func.migrationsDir,
         migrationsTable: "__spfn_fn_migrations"
       });
-      console.log(chalk11.green(`  \u2713 ${func.packageName} migrations applied`));
+      console.log(chalk12.green(`  \u2713 ${func.packageName} migrations applied`));
       executedCount++;
     }
   } finally {
@@ -2113,6 +2113,7 @@ import chalk10 from "chalk";
 // src/commands/db/utils/drizzle.ts
 import { existsSync as existsSync15, writeFileSync as writeFileSync9, unlinkSync as unlinkSync2 } from "fs";
 import { spawn } from "child_process";
+import { pathToFileURL } from "url";
 import chalk9 from "chalk";
 import ora6 from "ora";
 import { env } from "@spfn/core/config";
@@ -2188,6 +2189,50 @@ async function runWithSpinner(spinnerText, command, successMessage, failMessage)
     process.exit(1);
   }
 }
+var tsxRegistered = false;
+async function ensureTsxLoader() {
+  if (tsxRegistered) return;
+  try {
+    const tsx = await import("tsx/esm/api");
+    tsx.register();
+    tsxRegistered = true;
+  } catch {
+  }
+}
+async function loadSchemaImports(schemaFiles) {
+  const hasTsFiles = schemaFiles.some((f) => f.endsWith(".ts"));
+  if (hasTsFiles) {
+    await ensureTsxLoader();
+  }
+  const imports = {};
+  for (const file of schemaFiles) {
+    const moduleUrl = pathToFileURL(file).href;
+    const mod = await import(moduleUrl);
+    for (const [key, value] of Object.entries(mod)) {
+      if (key !== "default") {
+        imports[key] = value;
+      }
+    }
+  }
+  return imports;
+}
+async function createPushConnection() {
+  loadEnv();
+  if (!env.DATABASE_URL) {
+    throw new Error("DATABASE_URL is required");
+  }
+  const pg = await import("pg");
+  const { drizzle } = await import("drizzle-orm/node-postgres");
+  const pool = new pg.default.Pool({
+    connectionString: env.DATABASE_URL,
+    max: 1
+  });
+  const db = drizzle(pool);
+  return {
+    db,
+    close: () => pool.end()
+  };
+}
 // src/commands/db/generate.ts
 async function dbGenerate() {
@@ -2202,35 +2247,203 @@ async function dbGenerate() {
 }
 // src/commands/db/push.ts
-import chalk12 from "chalk";
+import chalk13 from "chalk";
+import prompts3 from "prompts";
 import "@spfn/core/config";
-async function dbPush() {
-  await runWithSpinner(
-    "Pushing schema changes to database...",
-    "push",
-    "Schema pushed successfully",
-    "Failed to push schema"
-  );
+import { loadEnv as loadEnv3 } from "@spfn/core/server";
+import { sql } from "drizzle-orm";
+// src/commands/db/utils/sql-classifier.ts
+var DESTRUCTIVE_PATTERNS = [
+  { pattern: /^\s*DROP\s+TABLE/i, reason: "Drops entire table" },
+  { pattern: /^\s*DROP\s+INDEX/i, reason: "Drops index" },
+  { pattern: /^\s*DROP\s+SCHEMA/i, reason: "Drops schema" },
+  { pattern: /^\s*DROP\s+TYPE/i, reason: "Drops custom type" },
+  { pattern: /ALTER\s+TABLE\s+.*\bDROP\s+COLUMN\b/i, reason: "Drops column" },
+  { pattern: /ALTER\s+TABLE\s+.*\bDROP\s+CONSTRAINT\b/i, reason: "Drops constraint" },
+  { pattern: /ALTER\s+TABLE\s+.*ALTER\s+COLUMN\s+.*\bTYPE\b/i, reason: "Changes column type (potential data loss)" },
+  { pattern: /ALTER\s+TYPE\s+.*\bRENAME\s+VALUE\b/i, reason: "Renames enum value" },
+  { pattern: /^\s*TRUNCATE\b/i, reason: "Truncates table data" },
+  { pattern: /^\s*DELETE\s+FROM\b/i, reason: "Deletes table data" }
+];
+var WARNING_PATTERNS = [
+  { pattern: /ALTER\s+TABLE\s+.*ALTER\s+COLUMN\s+.*\bSET\s+NOT\s+NULL\b/i, reason: "Adds NOT NULL (fails if NULLs exist)" },
+  { pattern: /ALTER\s+TABLE\s+.*\bRENAME\s+COLUMN\b/i, reason: "Renames column" }
+];
+function classifyStatement(sql2) {
+  for (const { pattern, reason } of DESTRUCTIVE_PATTERNS) {
+    if (pattern.test(sql2)) {
+      return { sql: sql2, category: "destructive", reason };
+    }
+  }
+  for (const { pattern, reason } of WARNING_PATTERNS) {
+    if (pattern.test(sql2)) {
+      return { sql: sql2, category: "warning", reason };
+    }
+  }
+  return { sql: sql2, category: "safe", reason: "" };
+}
+function classifyStatements(statements) {
+  const result = { safe: [], destructive: [], warning: [] };
+  for (const sql2 of statements) {
+    const classified = classifyStatement(sql2);
+    result[classified.category].push(classified);
+  }
+  return result;
+}
+// src/commands/db/utils/push-display.ts
+import chalk11 from "chalk";
+function formatSql(sql2) {
+  return sql2.replace(/\s+/g, " ").trim();
+}
+function printStatements(statements, color) {
+  for (const stmt of statements) {
+    console.log(color(`   ${formatSql(stmt.sql)}`));
+    if (stmt.reason) {
+      console.log(chalk11.dim(`   \u2192 ${stmt.reason}`));
+    }
+  }
+}
+function displayClassifiedStatements(result) {
+  if (result.safe.length > 0) {
+    console.log(chalk11.green(`
+\u2705 Safe changes (${result.safe.length}):`));
+    printStatements(result.safe, chalk11.green);
+  }
+  if (result.warning.length > 0) {
+    console.log(chalk11.yellow(`
+\u26A0\uFE0F  Warnings (${result.warning.length}):`));
+    printStatements(result.warning, chalk11.yellow);
+  }
+  if (result.destructive.length > 0) {
+    console.log(chalk11.red(`
+\u274C Destructive changes (${result.destructive.length}):`));
+    printStatements(result.destructive, chalk11.red);
+  }
+}
+function displayDryRunSummary(result) {
+  const total = result.safe.length + result.warning.length + result.destructive.length;
+  console.log(chalk11.cyan(`
+\u{1F50D} Dry-run: ${total} statement(s) detected
+`));
+  displayClassifiedStatements(result);
+  console.log("");
+}
+function displayApplySummary(applied, skipped) {
+  if (applied > 0) {
+    console.log(chalk11.green(`
+\u2705 Applied ${applied} statement(s)`));
+  }
+  if (skipped > 0) {
+    console.log(chalk11.yellow(`\u23ED\uFE0F  Skipped ${skipped} destructive statement(s)`));
+  }
+  console.log("");
+}
+// src/commands/db/push.ts
+async function dbPush(options = {}) {
+  validateDatabasePrerequisites();
+  loadEnv3();
+  const { getDrizzleConfig } = await import("@spfn/core/db");
+  const config = getDrizzleConfig({
+    cwd: process.cwd(),
+    expandGlobs: true,
+    autoDetectSchemas: true,
+    disablePackageDiscovery: true
+  });
+  const schemaFiles = Array.isArray(config.schema) ? config.schema : [config.schema];
+  if (schemaFiles.length === 0) {
+    console.log(chalk13.yellow("No schema files found."));
+    return;
+  }
+  console.log(chalk13.dim(`Found ${schemaFiles.length} schema file(s)
+`));
+  const imports = await loadSchemaImports(schemaFiles);
+  const { db, close } = await createPushConnection();
+  try {
+    const { pushSchema } = await import("drizzle-kit/api");
+    const { statementsToExecute, apply } = await pushSchema(
+      imports,
+      db,
+      config.schemaFilter ?? ["public"]
+    );
+    if (statementsToExecute.length === 0) {
+      console.log(chalk13.green("\u2705 No changes detected \u2014 database is up to date\n"));
+      await applyFunctionMigrations();
+      return;
+    }
+    const result = classifyStatements(statementsToExecute);
+    if (options.dryRun) {
+      displayDryRunSummary(result);
+      return;
+    }
+    displayClassifiedStatements(result);
+    if (options.force) {
+      console.log(chalk13.dim("\n--force: applying all changes..."));
+      await apply();
+      displayApplySummary(statementsToExecute.length, 0);
+    } else if (result.destructive.length === 0) {
+      await apply();
+      displayApplySummary(statementsToExecute.length, 0);
+    } else {
+      const safeCount = result.safe.length + result.warning.length;
+      if (safeCount > 0) {
+        for (const stmt of [...result.safe, ...result.warning]) {
+          await db.execute(sql.raw(stmt.sql));
+        }
+        console.log(chalk13.green(`
+\u2705 Applied ${safeCount} safe statement(s)`));
+      }
+      console.log(chalk13.red(`
+\u274C ${result.destructive.length} destructive change(s) require confirmation:`));
+      for (const stmt of result.destructive) {
+        console.log(chalk13.red(`   ${stmt.sql.replace(/\s+/g, " ").trim()}`));
+        console.log(chalk13.dim(`   \u2192 ${stmt.reason}`));
+      }
+      const { confirm } = await prompts3({
+        type: "confirm",
+        name: "confirm",
+        message: "Apply destructive changes?",
+        initial: false
+      });
+      if (confirm) {
+        for (const stmt of result.destructive) {
+          await db.execute(sql.raw(stmt.sql));
+        }
+        displayApplySummary(statementsToExecute.length, 0);
+      } else {
+        displayApplySummary(safeCount, result.destructive.length);
+        console.log(chalk13.dim("Tip: Use --force to apply all changes without prompting.\n"));
+      }
+    }
+    await applyFunctionMigrations();
+  } finally {
+    await close();
+  }
+}
+async function applyFunctionMigrations() {
   const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
   const functions = discoverFunctionMigrations2(process.cwd());
-  if (functions.length > 0) {
-    console.log(chalk12.blue("\n\u{1F4E6} Applying function package migrations:"));
-    functions.forEach((func) => {
-      console.log(chalk12.dim(`  - ${func.packageName}`));
-    });
-    try {
-      await executeFunctionMigrations2(functions);
-      console.log(chalk12.green("\n\u2705 All function migrations applied\n"));
-    } catch (error) {
-      console.error(chalk12.red("\n\u274C Failed to apply function migrations"));
-      console.error(chalk12.red(error instanceof Error ? error.message : "Unknown error"));
-      process.exit(1);
-    }
+  if (functions.length === 0) {
+    return;
+  }
+  console.log(chalk13.blue("\n\u{1F4E6} Applying function package migrations:"));
+  functions.forEach((func) => {
+    console.log(chalk13.dim(`  - ${func.packageName}`));
+  });
+  try {
+    await executeFunctionMigrations2(functions);
+    console.log(chalk13.green("\n\u2705 All function migrations applied\n"));
+  } catch (error) {
+    console.error(chalk13.red("\n\u274C Failed to apply function migrations"));
+    console.error(chalk13.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
   }
 }
 // src/commands/db/migrate.ts
-import chalk16 from "chalk";
+import chalk17 from "chalk";
 import { join as join16 } from "path";
 import { existsSync as existsSync18 } from "fs";
@@ -2238,7 +2451,7 @@ import { existsSync as existsSync18 } from "fs";
 import { promises as fs3 } from "fs";
 import path3 from "path";
 import { spawn as spawn2 } from "child_process";
-import chalk15 from "chalk";
+import chalk16 from "chalk";
 import ora7 from "ora";
 // src/commands/db/utils/database.ts
@@ -2307,14 +2520,14 @@ function formatTimestamp() {
 import { promises as fs2 } from "fs";
 import { existsSync as existsSync17 } from "fs";
 import path2 from "path";
-import chalk14 from "chalk";
+import chalk15 from "chalk";
 // src/commands/db/utils/metadata.ts
 import { promises as fs } from "fs";
 import path from "path";
 import { promisify } from "util";
 import { exec } from "child_process";
-import chalk13 from "chalk";
+import chalk14 from "chalk";
 var execAsync = promisify(exec);
 async function collectGitInfo() {
   try {
@@ -2377,7 +2590,7 @@ async function collectMigrationInfo(dbUrl) {
       await pool.end();
     }
   } catch (error) {
-    console.log(chalk13.dim("\u26A0\uFE0F  Could not fetch migration info"));
+    console.log(chalk14.dim("\u26A0\uFE0F  Could not fetch migration info"));
     return void 0;
   }
 }
@@ -2385,9 +2598,9 @@ async function saveBackupMetadata(metadata, backupFilename) {
   const metadataPath = backupFilename.replace(/\.(sql|dump)$/, ".meta.json");
   try {
     await fs.writeFile(metadataPath, JSON.stringify(metadata, null, 2));
-    console.log(chalk13.dim(`\u2713 Metadata saved: ${path.basename(metadataPath)}`));
+    console.log(chalk14.dim(`\u2713 Metadata saved: ${path.basename(metadataPath)}`));
   } catch (error) {
-    console.log(chalk13.dim("\u26A0\uFE0F  Could not save metadata"));
+    console.log(chalk14.dim("\u26A0\uFE0F  Could not save metadata"));
   }
 }
 async function loadBackupMetadata(backupFilename) {
@@ -2416,10 +2629,10 @@ async function ensureBackupInGitignore() {
     if (!hasBackupsIgnore) {
       const entry = exists && content && !content.endsWith("\n") ? "\n\n# Database backups\nbackups/\n" : "# Database backups\nbackups/\n";
       await fs2.appendFile(gitignorePath, entry);
-      console.log(chalk14.dim("\u2713 Added backups/ to .gitignore"));
+      console.log(chalk15.dim("\u2713 Added backups/ to .gitignore"));
     }
   } catch (error) {
-    console.log(chalk14.dim("\u26A0\uFE0F  Could not update .gitignore"));
+    console.log(chalk15.dim("\u26A0\uFE0F  Could not update .gitignore"));
   }
 }
 async function ensureBackupDir() {
@@ -2467,14 +2680,14 @@ async function listBackupFiles() {
 // src/commands/db/backup.ts
 import { env as env3 } from "@spfn/core/config";
-import { loadEnv as loadEnv3 } from "@spfn/core/server";
+import { loadEnv as loadEnv4 } from "@spfn/core/server";
 async function dbBackup(options) {
-  console.log(chalk15.blue("\u{1F4BE} Creating database backup...\n"));
-  loadEnv3();
+  console.log(chalk16.blue("\u{1F4BE} Creating database backup...\n"));
+  loadEnv4();
   const dbUrl = env3.DATABASE_URL;
   if (!dbUrl) {
-    console.error(chalk15.red("\u274C DATABASE_URL not found in environment"));
-    console.log(chalk15.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    console.error(chalk16.red("\u274C DATABASE_URL not found in environment"));
+    console.log(chalk16.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
     process.exit(1);
   }
   const dbInfo = parseDatabaseUrl(dbUrl);
@@ -2484,7 +2697,7 @@ async function dbBackup(options) {
   const ext = format === "sql" ? "sql" : "dump";
   const filename = options.output || path3.join(backupDir, `${dbInfo.database}_${timestamp}.${ext}`);
   if (options.dataOnly && options.schemaOnly) {
-    console.error(chalk15.red("\u274C Cannot use --data-only and --schema-only together"));
+    console.error(chalk16.red("\u274C Cannot use --data-only and --schema-only together"));
     process.exit(1);
   }
   const args = [
@@ -2530,11 +2743,11 @@ async function dbBackup(options) {
           const stats = await fs3.stat(filename);
           const size = formatBytes(stats.size);
           spinner.succeed("Backup created");
-          console.log(chalk15.green(`
+          console.log(chalk16.green(`
 \u2705 Backup created successfully`));
-          console.log(chalk15.gray(`   File: ${filename}`));
-          console.log(chalk15.gray(`   Size: ${size}`));
-          console.log(chalk15.dim("\n\u{1F4CB} Collecting metadata..."));
+          console.log(chalk16.gray(`   File: ${filename}`));
+          console.log(chalk16.gray(`   Size: ${size}`));
+          console.log(chalk16.dim("\n\u{1F4CB} Collecting metadata..."));
           const [gitInfo, migrationInfo] = await Promise.all([
             collectGitInfo(),
             collectMigrationInfo(dbUrl)
@@ -2574,11 +2787,11 @@ async function dbBackup(options) {
       reject(error);
     });
   }).catch((error) => {
-    console.error(chalk15.red("\n\u274C Failed to create backup"));
+    console.error(chalk16.red("\n\u274C Failed to create backup"));
     if (errorOutput.includes("pg_dump: command not found") || errorOutput.includes("not found")) {
-      console.error(chalk15.yellow("\n\u{1F4A1} pg_dump is not installed. Please install PostgreSQL client tools."));
+      console.error(chalk16.yellow("\n\u{1F4A1} pg_dump is not installed. Please install PostgreSQL client tools."));
     } else {
-      console.error(chalk15.red(error instanceof Error ? error.message : "Unknown error"));
+      console.error(chalk16.red(error instanceof Error ? error.message : "Unknown error"));
     }
     process.exit(1);
   });
@@ -2586,7 +2799,7 @@ async function dbBackup(options) {
 // src/commands/db/migrate.ts
 import { env as env4 } from "@spfn/core/config";
-import { loadEnv as loadEnv4 } from "@spfn/core/server";
+import { loadEnv as loadEnv5 } from "@spfn/core/server";
 var FUNCTION_MIGRATIONS_TABLE = "__spfn_fn_migrations";
 var PROJECT_MIGRATIONS_TABLE = "__drizzle_migrations";
 async function dbMigrate(options = {}) {
@@ -2596,7 +2809,7 @@ async function dbMigrate(options = {}) {
     process.exit(1);
   }
   if (options.withBackup) {
-    console.log(chalk16.blue("\u{1F4E6} Creating pre-migration backup...\n"));
+    console.log(chalk17.blue("\u{1F4E6} Creating pre-migration backup...\n"));
     await dbBackup({
       format: "custom",
       tag: "pre-migration",
@@ -2607,9 +2820,9 @@ async function dbMigrate(options = {}) {
   const { drizzle } = await import("drizzle-orm/postgres-js");
   const { migrate } = await import("drizzle-orm/postgres-js/migrator");
   const postgres = await import("postgres");
-  loadEnv4();
+  loadEnv5();
   if (!env4.DATABASE_URL) {
-    console.error(chalk16.red("\u274C DATABASE_URL not found in environment"));
+    console.error(chalk17.red("\u274C DATABASE_URL not found in environment"));
     process.exit(1);
   }
   const { discoverFunctionMigrations: discoverFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
@@ -2618,20 +2831,20 @@ async function dbMigrate(options = {}) {
     const fnConn = postgres.default(env4.DATABASE_URL, { max: 1 });
     const fnDb = drizzle(fnConn);
     try {
-      console.log(chalk16.blue("\u{1F4E6} Applying function package migrations:"));
+      console.log(chalk17.blue("\u{1F4E6} Applying function package migrations:"));
       functions.forEach((func) => {
-        console.log(chalk16.dim(`  - ${func.packageName}`));
+        console.log(chalk17.dim(`  - ${func.packageName}`));
       });
       for (const func of functions) {
-        console.log(chalk16.blue(`
+        console.log(chalk17.blue(`
   \u{1F4E6} Running ${func.packageName} migrations...`));
         await migrate(fnDb, {
           migrationsFolder: func.migrationsDir,
           migrationsTable: FUNCTION_MIGRATIONS_TABLE
         });
-        console.log(chalk16.green(`  \u2713 ${func.packageName} migrations applied`));
+        console.log(chalk17.green(`  \u2713 ${func.packageName} migrations applied`));
       }
-      console.log(chalk16.green("\u2705 Function migrations applied\n"));
+      console.log(chalk17.green("\u2705 Function migrations applied\n"));
     } finally {
       await fnConn.end();
     }
@@ -2641,39 +2854,39 @@ async function dbMigrate(options = {}) {
     const projConn = postgres.default(env4.DATABASE_URL, { max: 1 });
     const projDb = drizzle(projConn);
     try {
-      console.log(chalk16.blue("\u{1F4E6} Running project migrations..."));
+      console.log(chalk17.blue("\u{1F4E6} Running project migrations..."));
       await migrate(projDb, {
         migrationsFolder: projectMigrationsDir,
         migrationsTable: PROJECT_MIGRATIONS_TABLE
       });
-      console.log(chalk16.green("\u2705 Project migrations applied successfully"));
+      console.log(chalk17.green("\u2705 Project migrations applied successfully"));
     } finally {
       await projConn.end();
     }
   } else {
-    console.log(chalk16.dim("No project migrations found (src/server/drizzle)"));
+    console.log(chalk17.dim("No project migrations found (src/server/drizzle)"));
   }
 }
 // src/commands/db/studio.ts
-import chalk17 from "chalk";
+import chalk18 from "chalk";
 import { existsSync as existsSync19, writeFileSync as writeFileSync10, unlinkSync as unlinkSync3 } from "fs";
 import { spawn as spawn3 } from "child_process";
 import { env as env5 } from "@spfn/core/config";
 import "@spfn/core/config";
 async function dbStudio(requestedPort) {
-  console.log(chalk17.blue("\u{1F3A8} Opening Drizzle Studio...\n"));
+  console.log(chalk18.blue("\u{1F3A8} Opening Drizzle Studio...\n"));
   const defaultPort = 4983;
   const startPort = requestedPort || defaultPort;
   let port;
   try {
     port = await findAvailablePort(startPort);
     if (port !== startPort) {
-      console.log(chalk17.yellow(`\u26A0\uFE0F  Port ${startPort} is in use, using port ${port} instead
+      console.log(chalk18.yellow(`\u26A0\uFE0F  Port ${startPort} is in use, using port ${port} instead
 `));
     }
   } catch (error) {
-    console.error(chalk17.red(error instanceof Error ? error.message : "Failed to find available port"));
+    console.error(chalk18.red(error instanceof Error ? error.message : "Failed to find available port"));
     process.exit(1);
   }
   const hasUserConfig = existsSync19("./drizzle.config.ts");
@@ -2682,8 +2895,8 @@ async function dbStudio(requestedPort) {
     const configPath = hasUserConfig ? "./drizzle.config.ts" : tempConfigPath;
     if (!hasUserConfig) {
       if (!env5.DATABASE_URL) {
-        console.error(chalk17.red("\u274C DATABASE_URL not found in environment"));
-        console.log(chalk17.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+        console.error(chalk18.red("\u274C DATABASE_URL not found in environment"));
+        console.log(chalk18.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
         process.exit(1);
       }
       const { generateDrizzleConfigFile } = await import("@spfn/core/db");
@@ -2694,7 +2907,7 @@ async function dbStudio(requestedPort) {
         // Expand glob patterns for Studio compatibility
       });
       writeFileSync10(tempConfigPath, configContent);
-      console.log(chalk17.dim("Using auto-generated Drizzle config\n"));
+      console.log(chalk18.dim("Using auto-generated Drizzle config\n"));
     }
     const studioProcess = spawn3("drizzle-kit", ["studio", `--port=${port}`, `--config=${configPath}`], {
       stdio: "inherit",
@@ -2709,19 +2922,19 @@ async function dbStudio(requestedPort) {
     studioProcess.on("exit", (code) => {
       cleanup();
       if (code !== 0 && code !== null) {
-        console.error(chalk17.red(`
+        console.error(chalk18.red(`
 \u274C Drizzle Studio exited with code ${code}`));
         process.exit(code);
       }
     });
     studioProcess.on("error", (error) => {
       cleanup();
-      console.error(chalk17.red("\u274C Failed to start Drizzle Studio"));
-      console.error(chalk17.red(error.message));
+      console.error(chalk18.red("\u274C Failed to start Drizzle Studio"));
+      console.error(chalk18.red(error.message));
       process.exit(1);
     });
     process.on("SIGINT", () => {
-      console.log(chalk17.yellow("\n\n\u{1F44B} Shutting down Drizzle Studio..."));
+      console.log(chalk18.yellow("\n\n\u{1F44B} Shutting down Drizzle Studio..."));
       studioProcess.kill("SIGTERM");
       cleanup();
       process.exit(0);
@@ -2735,25 +2948,25 @@ async function dbStudio(requestedPort) {
     if (!hasUserConfig && existsSync19(tempConfigPath)) {
       unlinkSync3(tempConfigPath);
     }
-    console.error(chalk17.red("\u274C Failed to start Drizzle Studio"));
-    console.error(chalk17.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk18.red("\u274C Failed to start Drizzle Studio"));
+    console.error(chalk18.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 // src/commands/db/drop.ts
-import chalk18 from "chalk";
-import prompts3 from "prompts";
+import chalk19 from "chalk";
+import prompts4 from "prompts";
 async function dbDrop() {
-  console.log(chalk18.yellow("\u26A0\uFE0F  WARNING: This will drop all tables in your database!"));
-  const { confirm } = await prompts3({
+  console.log(chalk19.yellow("\u26A0\uFE0F  WARNING: This will drop all tables in your database!"));
+  const { confirm } = await prompts4({
     type: "confirm",
     name: "confirm",
     message: "Are you sure you want to drop all tables?",
     initial: false
   });
   if (!confirm) {
-    console.log(chalk18.gray("Cancelled."));
+    console.log(chalk19.gray("Cancelled."));
     process.exit(0);
   }
   await runWithSpinner(
@@ -2765,7 +2978,7 @@ async function dbDrop() {
 }
 // src/commands/db/check.ts
-import chalk19 from "chalk";
+import chalk20 from "chalk";
 import ora8 from "ora";
 async function dbCheck() {
   const spinner = ora8("Checking database connection...").start();
@@ -2774,7 +2987,7 @@ async function dbCheck() {
     spinner.succeed("Database connection OK");
   } catch (error) {
     spinner.fail("Database connection failed");
-    console.error(chalk19.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk20.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
@@ -2782,28 +2995,28 @@ async function dbCheck() {
 // src/commands/db/restore.ts
 import path4 from "path";
 import { spawn as spawn4 } from "child_process";
-import chalk20 from "chalk";
+import chalk21 from "chalk";
 import ora9 from "ora";
-import prompts4 from "prompts";
+import prompts5 from "prompts";
 import { env as env6 } from "@spfn/core/config";
-import { loadEnv as loadEnv5 } from "@spfn/core/server";
+import { loadEnv as loadEnv6 } from "@spfn/core/server";
 async function dbRestore(backupFile, options = {}) {
-  console.log(chalk20.blue("\u267B\uFE0F  Restoring database from backup...\n"));
-  loadEnv5();
+  console.log(chalk21.blue("\u267B\uFE0F  Restoring database from backup...\n"));
+  loadEnv6();
   const dbUrl = env6.DATABASE_URL;
   if (!dbUrl) {
-    console.error(chalk20.red("\u274C DATABASE_URL not found in environment"));
-    console.log(chalk20.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
+    console.error(chalk21.red("\u274C DATABASE_URL not found in environment"));
+    console.log(chalk21.yellow("\n\u{1F4A1} Tip: Add DATABASE_URL to your .env file"));
     process.exit(1);
   }
   let file = backupFile;
   if (!file) {
     const backups = await listBackupFiles();
     if (backups.length === 0) {
-      console.log(chalk20.yellow("No backups found in ./backups directory"));
+      console.log(chalk21.yellow("No backups found in ./backups directory"));
       process.exit(0);
     }
-    const { selected } = await prompts4({
+    const { selected } = await prompts5({
       type: "select",
       name: "selected",
       message: "Select backup to restore:",
@@ -2813,31 +3026,31 @@ async function dbRestore(backupFile, options = {}) {
       }))
     });
     if (!selected) {
-      console.log(chalk20.gray("Cancelled"));
+      console.log(chalk21.gray("Cancelled"));
       process.exit(0);
     }
     file = selected;
   }
   if (!file) {
-    console.error(chalk20.red("\u274C No backup file selected"));
+    console.error(chalk21.red("\u274C No backup file selected"));
     process.exit(1);
   }
   const metadata = await loadBackupMetadata(file);
   if (metadata) {
-    console.log(chalk20.blue("\n\u{1F4CB} Backup Information:\n"));
-    console.log(chalk20.dim(`  Database: ${metadata.database}`));
-    console.log(chalk20.dim(`  Created: ${new Date(metadata.timestamp).toLocaleString()}`));
+    console.log(chalk21.blue("\n\u{1F4CB} Backup Information:\n"));
+    console.log(chalk21.dim(`  Database: ${metadata.database}`));
+    console.log(chalk21.dim(`  Created: ${new Date(metadata.timestamp).toLocaleString()}`));
     if (metadata.environment) {
-      console.log(chalk20.dim(`  Environment: ${metadata.environment}`));
+      console.log(chalk21.dim(`  Environment: ${metadata.environment}`));
     }
     if (metadata.tags && metadata.tags.length > 0) {
-      console.log(chalk20.dim(`  Tags: ${metadata.tags.join(", ")}`));
+      console.log(chalk21.dim(`  Tags: ${metadata.tags.join(", ")}`));
     }
     if (metadata.backup.dataOnly) {
-      console.log(chalk20.yellow("  \u26A0\uFE0F  Data-only backup (no schema)"));
+      console.log(chalk21.yellow("  \u26A0\uFE0F  Data-only backup (no schema)"));
     }
     if (metadata.backup.schemaOnly) {
-      console.log(chalk20.yellow("  \u26A0\uFE0F  Schema-only backup (no data)"));
+      console.log(chalk21.yellow("  \u26A0\uFE0F  Schema-only backup (no data)"));
     }
     const warnings2 = [];
     const [currentGitInfo, currentMigrationInfo] = await Promise.all([
@@ -2860,23 +3073,23 @@ async function dbRestore(backupFile, options = {}) {
       }
     }
     if (warnings2.length > 0) {
-      console.log(chalk20.yellow("\n\u26A0\uFE0F  Version Warnings:\n"));
-      warnings2.forEach((warning) => console.log(chalk20.yellow(`  - ${warning}`)));
+      console.log(chalk21.yellow("\n\u26A0\uFE0F  Version Warnings:\n"));
+      warnings2.forEach((warning) => console.log(chalk21.yellow(`  - ${warning}`)));
       console.log("");
     }
   }
-  const { confirm } = await prompts4({
+  const { confirm } = await prompts5({
     type: "confirm",
     name: "confirm",
-    message: chalk20.yellow("\u26A0\uFE0F  This will replace all data in the database. Continue?"),
+    message: chalk21.yellow("\u26A0\uFE0F  This will replace all data in the database. Continue?"),
     initial: false
   });
   if (!confirm) {
-    console.log(chalk20.gray("Cancelled"));
+    console.log(chalk21.gray("Cancelled"));
     process.exit(0);
   }
   if (options.dataOnly && options.schemaOnly) {
-    console.error(chalk20.red("\u274C Cannot use --data-only and --schema-only together"));
+    console.error(chalk21.red("\u274C Cannot use --data-only and --schema-only together"));
     process.exit(1);
   }
   const dbInfo = parseDatabaseUrl(dbUrl);
@@ -2905,8 +3118,8 @@ async function dbRestore(backupFile, options = {}) {
     args.push(file);
   } else {
     if (options.dataOnly || options.schemaOnly) {
-      console.log(chalk20.yellow("\u26A0\uFE0F  Note: --data-only and --schema-only options only work with custom format backups (.dump)"));
-      console.log(chalk20.yellow("    For SQL files, the backup must have been created with the desired option.\n"));
+      console.log(chalk21.yellow("\u26A0\uFE0F  Note: --data-only and --schema-only options only work with custom format backups (.dump)"));
+      console.log(chalk21.yellow("    For SQL files, the backup must have been created with the desired option.\n"));
     }
     args.push("-h", dbInfo.host);
     args.push("-p", dbInfo.port);
@@ -2952,7 +3165,7 @@ async function dbRestore(backupFile, options = {}) {
       }
       if (verbose) {
         spinner.stop();
-        console.log(chalk20.dim(`  ${line.trim()}`));
+        console.log(chalk21.dim(`  ${line.trim()}`));
         spinner.start();
       }
     }
@@ -2960,7 +3173,7 @@ async function dbRestore(backupFile, options = {}) {
   restoreProcess.stdout?.on("data", (data) => {
     if (verbose) {
       spinner.stop();
-      console.log(chalk20.dim(`  ${data.toString().trim()}`));
+      console.log(chalk21.dim(`  ${data.toString().trim()}`));
       spinner.start();
     }
   });
@@ -2970,31 +3183,31 @@ async function dbRestore(backupFile, options = {}) {
         const summary = objectCount > 0 ? ` (${objectCount} objects)` : "";
         spinner.succeed(`Restore completed${summary}`);
         if (warnings.length > 0) {
-          console.log(chalk20.yellow(`
+          console.log(chalk21.yellow(`
 \u26A0\uFE0F  Warnings during restore (${warnings.length}):
 `));
           for (const w of warnings) {
-            console.log(chalk20.yellow(`  - ${w}`));
+            console.log(chalk21.yellow(`  - ${w}`));
           }
         }
-        console.log(chalk20.green("\n\u2705 Database restored successfully"));
+        console.log(chalk21.green("\n\u2705 Database restored successfully"));
         resolve2();
       } else {
         spinner.fail("Restore failed");
         if (errors.length > 0) {
-          console.error(chalk20.red(`
+          console.error(chalk21.red(`
 \u274C Errors (${errors.length}):
 `));
           for (const e of errors) {
-            console.error(chalk20.red(`  - ${e}`));
+            console.error(chalk21.red(`  - ${e}`));
           }
         }
         if (warnings.length > 0) {
-          console.log(chalk20.yellow(`
+          console.log(chalk21.yellow(`
 \u26A0\uFE0F  Warnings (${warnings.length}):
 `));
           for (const w of warnings) {
-            console.log(chalk20.yellow(`  - ${w}`));
+            console.log(chalk21.yellow(`  - ${w}`));
           }
         }
         const fallback = errors.length === 0 && warnings.length === 0 ? "Restore failed with no output" : "";
@@ -3008,7 +3221,7 @@ async function dbRestore(backupFile, options = {}) {
   }).catch((error) => {
     const msg = error instanceof Error ? error.message : "Unknown error";
     if (msg) {
-      console.error(chalk20.red(`
+      console.error(chalk21.red(`
 \u274C ${msg}`));
     }
     process.exit(1);
@@ -3016,17 +3229,17 @@ async function dbRestore(backupFile, options = {}) {
 }
 // src/commands/db/list.ts
-import chalk21 from "chalk";
+import chalk22 from "chalk";
 async function dbBackupList() {
-  console.log(chalk21.blue("\u{1F4CB} Database backups:\n"));
+  console.log(chalk22.blue("\u{1F4CB} Database backups:\n"));
   const backups = await listBackupFiles();
   if (backups.length === 0) {
-    console.log(chalk21.yellow("No backups found in ./backups directory"));
-    console.log(chalk21.gray("\n\u{1F4A1} Create a backup with: pnpm spfn db backup\n"));
+    console.log(chalk22.yellow("No backups found in ./backups directory"));
+    console.log(chalk22.gray("\n\u{1F4A1} Create a backup with: pnpm spfn db backup\n"));
     return;
   }
-  console.log(chalk21.bold("  Date                  Size        File"));
-  console.log(chalk21.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
+  console.log(chalk22.bold("  Date                  Size        File"));
+  console.log(chalk22.gray("  \u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500\u2500"));
   backups.forEach((backup) => {
     const date = backup.date.toLocaleString("en-US", {
       year: "numeric",
@@ -3037,23 +3250,23 @@ async function dbBackupList() {
       second: "2-digit"
     });
     const sizeStr = backup.size.padEnd(10);
-    console.log(chalk21.white(`  ${date}  ${sizeStr}  ${backup.name}`));
+    console.log(chalk22.white(`  ${date}  ${sizeStr}  ${backup.name}`));
   });
-  console.log(chalk21.gray(`
+  console.log(chalk22.gray(`
   Total: ${backups.length} backup(s)
 `));
 }
 // src/commands/db/clean.ts
 import { promises as fs4 } from "fs";
-import chalk22 from "chalk";
+import chalk23 from "chalk";
 import ora10 from "ora";
-import prompts5 from "prompts";
+import prompts6 from "prompts";
 async function dbBackupClean(options) {
-  console.log(chalk22.blue("\u{1F9F9} Cleaning old backups...\n"));
+  console.log(chalk23.blue("\u{1F9F9} Cleaning old backups...\n"));
   const backups = await listBackupFiles();
   if (backups.length === 0) {
-    console.log(chalk22.yellow("No backups found"));
+    console.log(chalk23.yellow("No backups found"));
     return;
   }
   let toDelete = [];
@@ -3070,41 +3283,142 @@ async function dbBackupClean(options) {
     toDelete = backups.slice(defaultKeep);
   }
   if (toDelete.length === 0) {
-    console.log(chalk22.green("\u2705 No backups to clean"));
+    console.log(chalk23.green("\u2705 No backups to clean"));
     return;
   }
-  console.log(chalk22.yellow(`The following ${toDelete.length} backup(s) will be deleted:
+  console.log(chalk23.yellow(`The following ${toDelete.length} backup(s) will be deleted:
 `));
   toDelete.forEach((backup) => {
-    console.log(chalk22.gray(`  - ${backup.name} (${backup.size})`));
+    console.log(chalk23.gray(`  - ${backup.name} (${backup.size})`));
   });
-  const { confirm } = await prompts5({
+  const { confirm } = await prompts6({
     type: "confirm",
     name: "confirm",
     message: "\nProceed with deletion?",
     initial: false
   });
   if (!confirm) {
-    console.log(chalk22.gray("Cancelled"));
+    console.log(chalk23.gray("Cancelled"));
     return;
   }
   const spinner = ora10("Deleting backups...").start();
   try {
     await Promise.all(toDelete.map((backup) => fs4.unlink(backup.path)));
     spinner.succeed("Backups deleted");
-    console.log(chalk22.green(`
+    console.log(chalk23.green(`
 \u2705 Deleted ${toDelete.length} backup(s)`));
   } catch (error) {
     spinner.fail("Failed to delete backups");
-    console.error(chalk22.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk23.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
+// src/commands/db/reindex.ts
+import { existsSync as existsSync20, readFileSync as readFileSync6, writeFileSync as writeFileSync11, renameSync, copyFileSync } from "fs";
+import { join as join17 } from "path";
+import chalk24 from "chalk";
+import { loadEnv as loadEnv7 } from "@spfn/core/server";
+function isTimestampPrefix(tag) {
+  const prefix = tag.split("_")[0];
+  return /^\d{5,}$/.test(prefix);
+}
+function parseTag(tag) {
+  const underscoreIdx = tag.indexOf("_");
+  if (underscoreIdx === -1) {
+    return { prefix: tag, suffix: "" };
+  }
+  return {
+    prefix: tag.substring(0, underscoreIdx),
+    suffix: tag.substring(underscoreIdx + 1)
+  };
+}
+async function dbReindex(options = {}) {
+  loadEnv7();
+  const { getDrizzleConfig } = await import("@spfn/core/db");
+  const config = getDrizzleConfig({ disablePackageDiscovery: true });
+  const outDir = config.out;
+  const journalPath = join17(outDir, "meta", "_journal.json");
+  if (!existsSync20(journalPath)) {
+    console.error(chalk24.red("\u274C No _journal.json found at:"), journalPath);
+    console.log(chalk24.yellow("\u{1F4A1} Run `spfn db generate` first to create migrations"));
+    process.exit(1);
+  }
+  const journal = JSON.parse(readFileSync6(journalPath, "utf-8"));
+  if (journal.entries.length === 0) {
+    console.log(chalk24.yellow("No migration entries found \u2014 nothing to reindex."));
+    return;
+  }
+  const renames = [];
+  const tagUpdates = [];
+  let skipped = 0;
+  for (const entry of journal.entries) {
+    if (isTimestampPrefix(entry.tag)) {
+      skipped++;
+      continue;
+    }
+    const { prefix: oldPrefix, suffix } = parseTag(entry.tag);
+    const newPrefix = String(entry.when);
+    const newTag = suffix ? `${newPrefix}_${suffix}` : newPrefix;
+    const oldSql = join17(outDir, `${entry.tag}.sql`);
+    const newSql = join17(outDir, `${newTag}.sql`);
+    if (existsSync20(oldSql)) {
+      renames.push({ type: "sql", from: oldSql, to: newSql });
+    }
+    const oldSnapshot = join17(outDir, "meta", `${oldPrefix}_snapshot.json`);
+    const newSnapshot = join17(outDir, "meta", `${newPrefix}_snapshot.json`);
+    if (existsSync20(oldSnapshot)) {
+      renames.push({ type: "snapshot", from: oldSnapshot, to: newSnapshot });
+    }
+    tagUpdates.push({ idx: entry.idx, oldTag: entry.tag, newTag });
+  }
+  if (tagUpdates.length === 0) {
+    console.log(chalk24.green("\u2705 All migrations already use timestamp prefix \u2014 nothing to do."));
+    if (skipped > 0) {
+      console.log(chalk24.dim(`   (${skipped} entries already timestamp-prefixed)`));
+    }
+    return;
+  }
+  console.log(chalk24.bold("\n\u{1F4CB} Reindex plan:\n"));
+  for (const update of tagUpdates) {
+    console.log(
+      chalk24.dim(`  [${update.idx}]`),
+      chalk24.red(update.oldTag),
+      chalk24.dim("\u2192"),
+      chalk24.green(update.newTag)
+    );
+  }
+  console.log(chalk24.dim(`
+  ${renames.length} file(s) to rename, ${tagUpdates.length} journal tag(s) to update`));
+  if (skipped > 0) {
+    console.log(chalk24.dim(`  ${skipped} entry/entries already timestamp-prefixed (skipped)`));
+  }
+  if (options.dryRun) {
+    console.log(chalk24.yellow("\n\u{1F50D} Dry run \u2014 no changes applied."));
+    return;
+  }
+  const backupPath = journalPath + ".bak";
+  copyFileSync(journalPath, backupPath);
+  console.log(chalk24.dim(`
+  Backed up journal \u2192 ${backupPath}`));
+  for (const rename of renames) {
+    renameSync(rename.from, rename.to);
+  }
+  for (const update of tagUpdates) {
+    const entry = journal.entries.find((e) => e.idx === update.idx);
+    if (entry) {
+      entry.tag = update.newTag;
+    }
+  }
+  writeFileSync11(journalPath, JSON.stringify(journal, null, 2) + "\n");
+  console.log(chalk24.green(`
+\u2705 Reindex complete \u2014 ${tagUpdates.length} migration(s) converted to timestamp prefix.`));
+}
 // src/commands/db/index.ts
 var dbCommand = new Command9("db").description("Database management commands (wraps Drizzle Kit)");
 dbCommand.command("generate").alias("g").description("Generate database migrations from schema changes").action(dbGenerate);
-dbCommand.command("push").description("Push schema changes directly to database (no migrations)").action(dbPush);
+dbCommand.command("push").description("Push schema changes to database (safe mode by default)").option("--force", "Apply all changes including destructive ones").option("--dry-run", "Show changes without applying").action((options) => dbPush(options));
 dbCommand.command("migrate").alias("m").description("Run pending migrations").option("--with-backup", "Create backup before running migrations").action((options) => dbMigrate(options));
 dbCommand.command("studio").description("Open Drizzle Studio (database GUI)").option("-p, --port <port>", "Studio port (auto-finds if in use)").action((options) => dbStudio(options.port ? Number(options.port) : void 0));
 dbCommand.command("drop").description("Drop all database tables (\u26A0\uFE0F  dangerous!)").action(dbDrop);
@@ -3113,31 +3427,32 @@ dbCommand.command("backup").description("Create a database backup").option("-f,
 dbCommand.command("restore [file]").description("Restore database from backup").option("--drop", "Drop existing tables before restore").option("-s, --schema <name>", "Restore specific schema only").option("--data-only", "Restore data only (requires custom format .dump file)").option("--schema-only", "Restore schema only (requires custom format .dump file)").option("-v, --verbose", "Show detailed restore progress").action((file, options) => dbRestore(file, options));
 dbCommand.command("backup:list").description("List all database backups").action(dbBackupList);
 dbCommand.command("backup:clean").description("Clean old database backups").option("-k, --keep <number>", "Keep N most recent backups", parseInt).option("-o, --older-than <days>", "Delete backups older than N days", parseInt).action((options) => dbBackupClean(options));
+dbCommand.command("reindex").description("Convert migration files from sequential to timestamp prefix").option("--dry-run", "Show changes without applying").action((options) => dbReindex(options));
 // src/commands/add.ts
 import { Command as Command10 } from "commander";
-import { existsSync as existsSync20, readFileSync as readFileSync6 } from "fs";
-import { join as join17 } from "path";
+import { existsSync as existsSync21, readFileSync as readFileSync7 } from "fs";
+import { join as join18 } from "path";
 import { exec as exec2 } from "child_process";
 import { promisify as promisify2 } from "util";
-import chalk23 from "chalk";
+import chalk25 from "chalk";
 import ora11 from "ora";
 var execAsync2 = promisify2(exec2);
 async function addPackage(packageName) {
   if (!packageName.includes("/")) {
-    console.error(chalk23.red("\u274C Please specify full package name"));
-    console.log(chalk23.yellow("\n\u{1F4A1} Examples:"));
-    console.log(chalk23.gray("  pnpm spfn add @spfn/cms"));
-    console.log(chalk23.gray("  pnpm spfn add @mycompany/spfn-analytics"));
+    console.error(chalk25.red("\u274C Please specify full package name"));
+    console.log(chalk25.yellow("\n\u{1F4A1} Examples:"));
+    console.log(chalk25.gray("  pnpm spfn add @spfn/cms"));
+    console.log(chalk25.gray("  pnpm spfn add @mycompany/spfn-analytics"));
     process.exit(1);
   }
-  console.log(chalk23.blue(`
+  console.log(chalk25.blue(`
 \u{1F4E6} Setting up ${packageName}...
 `));
   try {
-    const pkgPath = join17(process.cwd(), "node_modules", ...packageName.split("/"));
-    const pkgJsonPath = join17(pkgPath, "package.json");
-    if (!existsSync20(pkgJsonPath)) {
+    const pkgPath = join18(process.cwd(), "node_modules", ...packageName.split("/"));
+    const pkgJsonPath = join18(pkgPath, "package.json");
+    if (!existsSync21(pkgJsonPath)) {
       const installSpinner = ora11("Installing package...").start();
       try {
         await execAsync2(`pnpm add ${packageName}`);
@@ -3147,21 +3462,21 @@ async function addPackage(packageName) {
         throw error;
       }
     } else {
-      console.log(chalk23.gray("\u2713 Package already installed (using local version)\n"));
+      console.log(chalk25.gray("\u2713 Package already installed (using local version)\n"));
     }
-    if (!existsSync20(pkgJsonPath)) {
+    if (!existsSync21(pkgJsonPath)) {
       throw new Error(`Package ${packageName} not found after installation`);
     }
-    const pkgJson = JSON.parse(readFileSync6(pkgJsonPath, "utf-8"));
+    const pkgJson = JSON.parse(readFileSync7(pkgJsonPath, "utf-8"));
     if (pkgJson.spfn?.migrations) {
-      console.log(chalk23.blue(`
+      console.log(chalk25.blue(`
 \u{1F5C4}\uFE0F  Setting up database for ${packageName}...
 `));
       const { env: env7 } = await import("@spfn/core/config");
       if (!env7.DATABASE_URL) {
-        console.log(chalk23.yellow("\u26A0\uFE0F  DATABASE_URL not found"));
-        console.log(chalk23.gray("Skipping database setup. Run migrations manually when ready:\n"));
-        console.log(chalk23.gray(`  pnpm spfn db push
+        console.log(chalk25.yellow("\u26A0\uFE0F  DATABASE_URL not found"));
+        console.log(chalk25.gray("Skipping database setup. Run migrations manually when ready:\n"));
+        console.log(chalk25.gray(`  pnpm spfn db push
 `));
       } else {
         const { discoverFunctionMigrations: discoverFunctionMigrations2, executeFunctionMigrations: executeFunctionMigrations2 } = await Promise.resolve().then(() => (init_function_migrations(), function_migrations_exports));
@@ -3177,25 +3492,25 @@ async function addPackage(packageName) {
             throw error;
           }
         } else {
-          console.log(chalk23.gray("\u2139\uFE0F  No migrations found for this package"));
+          console.log(chalk25.gray("\u2139\uFE0F  No migrations found for this package"));
         }
       }
     } else {
-      console.log(chalk23.gray("\n\u2139\uFE0F  No database migrations to apply"));
+      console.log(chalk25.gray("\n\u2139\uFE0F  No database migrations to apply"));
     }
-    console.log(chalk23.green(`
+    console.log(chalk25.green(`
 \u2705 ${packageName} installed successfully!
 `));
     if (pkgJson.spfn?.setupMessage) {
-      console.log(chalk23.cyan("\u{1F4DA} Setup Guide:"));
+      console.log(chalk25.cyan("\u{1F4DA} Setup Guide:"));
       console.log(pkgJson.spfn.setupMessage);
       console.log();
     }
   } catch (error) {
-    console.error(chalk23.red(`
+    console.error(chalk25.red(`
 \u274C Failed to install ${packageName}
 `));
-    console.error(chalk23.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk25.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
@@ -3205,16 +3520,16 @@ var addCommand = new Command10("add").description("Install and set up SPFN ecosy
 init_logger();
 import { Command as Command11 } from "commander";
 import ora12 from "ora";
-import { join as join26 } from "path";
-import { existsSync as existsSync23 } from "fs";
-import chalk25 from "chalk";
+import { join as join27 } from "path";
+import { existsSync as existsSync24 } from "fs";
+import chalk27 from "chalk";
 // src/commands/generate/prompts.ts
 init_logger();
-import prompts6 from "prompts";
-import chalk24 from "chalk";
+import prompts7 from "prompts";
+import chalk26 from "chalk";
 async function promptScope() {
-  const response = await prompts6({
+  const response = await prompts7({
     type: "text",
     name: "scope",
     message: "NPM scope (e.g., @mycompany, @username):",
@@ -3236,7 +3551,7 @@ async function promptScope() {
   return response.scope;
 }
 async function promptFunctionName() {
-  const response = await prompts6({
+  const response = await prompts7({
     type: "text",
     name: "fnName",
     message: "Function name:",
@@ -3257,7 +3572,7 @@ async function promptFunctionName() {
   return response.fnName;
 }
 async function promptDescription(fnName) {
-  const response = await prompts6({
+  const response = await prompts7({
     type: "text",
     name: "description",
     message: "Function description:",
@@ -3266,7 +3581,7 @@ async function promptDescription(fnName) {
   return response.description || "A description of what this module does";
 }
 async function promptEntities() {
-  const response = await prompts6({
+  const response = await prompts7({
     type: "list",
     name: "entities",
     message: "Entity names (comma-separated, press enter to skip):",
@@ -3278,14 +3593,14 @@ async function promptEntities() {
 async function confirmConfiguration(config) {
   const { scope, fnName, description, entities, enableCache, enableRoutes } = config;
   console.log("");
-  logger.info(chalk24.bold("\u26A1 Function Configuration:"));
-  console.log(`  ${chalk24.gray("Package:")}     ${chalk24.cyan(`${scope}/${fnName}`)}`);
-  console.log(`  ${chalk24.gray("Description:")} ${description}`);
-  console.log(`  ${chalk24.gray("Entities:")}    ${entities.length > 0 ? entities.join(", ") : chalk24.gray("none")}`);
-  console.log(`  ${chalk24.gray("Cache:")}       ${enableCache ? chalk24.green("yes") : chalk24.gray("no")}`);
-  console.log(`  ${chalk24.gray("Routes:")}      ${enableRoutes ? chalk24.green("yes") : chalk24.gray("no")}`);
+  logger.info(chalk26.bold("\u26A1 Function Configuration:"));
+  console.log(`  ${chalk26.gray("Package:")}     ${chalk26.cyan(`${scope}/${fnName}`)}`);
+  console.log(`  ${chalk26.gray("Description:")} ${description}`);
+  console.log(`  ${chalk26.gray("Entities:")}    ${entities.length > 0 ? entities.join(", ") : chalk26.gray("none")}`);
+  console.log(`  ${chalk26.gray("Cache:")}       ${enableCache ? chalk26.green("yes") : chalk26.gray("no")}`);
+  console.log(`  ${chalk26.gray("Routes:")}      ${enableRoutes ? chalk26.green("yes") : chalk26.gray("no")}`);
   console.log("");
-  const { confirmed } = await prompts6({
+  const { confirmed } = await prompts7({
     type: "confirm",
     name: "confirmed",
     message: "Create function?",
@@ -3299,12 +3614,12 @@ async function confirmConfiguration(config) {
 }
 // src/commands/generate/generators/structure.ts
-import { join as join25 } from "path";
-import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync17 } from "fs";
+import { join as join26 } from "path";
+import { mkdirSync as mkdirSync5, writeFileSync as writeFileSync18 } from "fs";
 // src/commands/generate/generators/config.ts
-import { join as join19 } from "path";
-import { writeFileSync as writeFileSync11, mkdirSync as mkdirSync3 } from "fs";
+import { join as join20 } from "path";
+import { writeFileSync as writeFileSync12, mkdirSync as mkdirSync3 } from "fs";
 // src/commands/generate/string-utils.ts
 function toPascalCase(str) {
@@ -3333,30 +3648,30 @@ function toSafeSchemaName(str) {
 }
 // src/commands/generate/template-loader.ts
-import { readFileSync as readFileSync7, existsSync as existsSync21 } from "fs";
-import { join as join18, dirname as dirname2 } from "path";
+import { readFileSync as readFileSync8, existsSync as existsSync22 } from "fs";
+import { join as join19, dirname as dirname2 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 function findTemplatesPath2() {
   const __filename = fileURLToPath2(import.meta.url);
   const __dirname2 = dirname2(__filename);
-  const distPath = join18(__dirname2, "commands", "generate", "templates");
-  if (existsSync21(distPath)) {
+  const distPath = join19(__dirname2, "commands", "generate", "templates");
+  if (existsSync22(distPath)) {
     return distPath;
   }
-  const sameDirPath = join18(__dirname2, "templates");
-  if (existsSync21(sameDirPath)) {
+  const sameDirPath = join19(__dirname2, "templates");
+  if (existsSync22(sameDirPath)) {
     return sameDirPath;
   }
-  const srcPath = join18(__dirname2, "..", "..", "src", "commands", "generate", "templates");
-  if (existsSync21(srcPath)) {
+  const srcPath = join19(__dirname2, "..", "..", "src", "commands", "generate", "templates");
+  if (existsSync22(srcPath)) {
     return srcPath;
   }
   throw new Error(`Templates directory not found. Tried: ${distPath}, ${sameDirPath}, ${srcPath}`);
 }
 function loadTemplate(templateName, variables) {
   const templatesDir = findTemplatesPath2();
-  const templatePath = join18(templatesDir, `${templateName}.template`);
-  let content = readFileSync7(templatePath, "utf-8");
+  const templatePath = join19(templatesDir, `${templateName}.template`);
+  let content = readFileSync8(templatePath, "utf-8");
   for (const [key, value] of Object.entries(variables)) {
     const regex = new RegExp(`\\{\\{${key}\\}\\}`, "g");
     content = content.replace(regex, value);
@@ -3458,8 +3773,8 @@ function generatePackageJson(fnDir, scope, fnName, description) {
       vitest: "^4.0.6"
     }
   };
-  writeFileSync11(
-    join19(fnDir, "package.json"),
+  writeFileSync12(
+    join20(fnDir, "package.json"),
     JSON.stringify(content, null, 4) + "\n"
   );
 }
@@ -3492,8 +3807,8 @@ function generateTsConfig(fnDir) {
     include: ["src/**/*"],
     exclude: ["node_modules", "dist", "**/*.test.ts", "**/__tests__/**"]
   };
-  writeFileSync11(
-    join19(fnDir, "tsconfig.json"),
+  writeFileSync12(
+    join20(fnDir, "tsconfig.json"),
     JSON.stringify(content, null, 4) + "\n"
   );
 }
@@ -3569,7 +3884,7 @@ export default defineConfig({
     ],
 });
 `;
-  writeFileSync11(join19(fnDir, "tsup.config.ts"), content);
+  writeFileSync12(join20(fnDir, "tsup.config.ts"), content);
 }
 function generateDrizzleConfig(fnDir, scope, fnName) {
   const schemaName = `spfn_${toSnakeCase(fnName)}`;
@@ -3589,7 +3904,7 @@ export default defineConfig({
     schemaFilter: ['${schemaName}'], // Only generate for ${fnName} schema
 });
 `;
-  writeFileSync11(join19(fnDir, "drizzle.config.ts"), content);
+  writeFileSync12(join20(fnDir, "drizzle.config.ts"), content);
 }
 function generateExampleGenerator(fnDir, scope, fnName) {
   const pascalName = toPascalCase(fnName);
@@ -3658,10 +3973,10 @@ export const moduleName = '${fnName}';
     };
 }
 `;
-  const generatorsDir = join19(fnDir, "src/server/generators");
+  const generatorsDir = join20(fnDir, "src/server/generators");
   mkdirSync3(generatorsDir, { recursive: true });
-  writeFileSync11(
-    join19(generatorsDir, "example-generator.ts"),
+  writeFileSync12(
+    join20(generatorsDir, "example-generator.ts"),
     content
   );
   const indexContent = `/**
@@ -3675,8 +3990,8 @@ export const moduleName = '${fnName}';
 export { create${pascalName}ExampleGenerator } from './example-generator.js';
 `;
-  writeFileSync11(
-    join19(generatorsDir, "index.ts"),
+  writeFileSync12(
+    join20(generatorsDir, "index.ts"),
     indexContent
   );
 }
@@ -4165,15 +4480,15 @@ Contributions are welcome! Please follow the development workflow above.
 MIT
 `;
-  writeFileSync11(join19(fnDir, "README.md"), content);
+  writeFileSync12(join20(fnDir, "README.md"), content);
 }
 // src/commands/generate/generators/entity.ts
-import { join as join20 } from "path";
-import { writeFileSync as writeFileSync12, existsSync as existsSync22 } from "fs";
+import { join as join21 } from "path";
+import { writeFileSync as writeFileSync13, existsSync as existsSync23 } from "fs";
 function generateSchema(fnDir, scope, fnName) {
-  const schemaFilePath = join20(fnDir, "src/server/entities/schema.ts");
-  if (existsSync22(schemaFilePath)) {
+  const schemaFilePath = join21(fnDir, "src/server/entities/schema.ts");
+  if (existsSync23(schemaFilePath)) {
     return;
   }
   const packageName = `${scope}/${fnName}`;
@@ -4184,7 +4499,7 @@ function generateSchema(fnDir, scope, fnName) {
     PACKAGE_NAME: packageName,
     SCHEMA_VAR_NAME: schemaVarName
   });
-  writeFileSync12(schemaFilePath, content);
+  writeFileSync13(schemaFilePath, content);
 }
 function generateEntity(fnDir, scope, fnName, entityName) {
   const safeScope = toSafeSchemaName(scope);
@@ -4203,8 +4518,8 @@ function generateEntity(fnDir, scope, fnName, entityName) {
     SCHEMA_VAR_NAME: schemaVarName,
     SCHEMA_FILE_NAME: schemaFileName
   });
-  writeFileSync12(
-    join20(fnDir, `src/server/entities/${toKebabCase(entityName)}.ts`),
+  writeFileSync13(
+    join21(fnDir, `src/server/entities/${toKebabCase(entityName)}.ts`),
     content
   );
 }
@@ -4212,12 +4527,12 @@ function generateEntitiesIndex(fnDir, entities) {
   const schemaExport = `export * from './schema';`;
   const entityExports = entities.map((entity) => `export * from './${toKebabCase(entity)}';`).join("\n");
   const content = [schemaExport, entityExports].filter(Boolean).join("\n");
-  writeFileSync12(join20(fnDir, "src/server/entities/index.ts"), content + "\n");
+  writeFileSync13(join21(fnDir, "src/server/entities/index.ts"), content + "\n");
 }
 // src/commands/generate/generators/repository.ts
-import { join as join21 } from "path";
-import { writeFileSync as writeFileSync13 } from "fs";
+import { join as join22 } from "path";
+import { writeFileSync as writeFileSync14 } from "fs";
 function generateRepository(fnDir, entityName) {
   const pascalName = toPascalCase(entityName);
   const repoName = `${entityName}Repository`;
@@ -4226,19 +4541,19 @@ function generateRepository(fnDir, entityName) {
     ENTITY_NAME: entityName,
     REPO_NAME: repoName
   });
-  writeFileSync13(
-    join21(fnDir, `src/server/repositories/${toKebabCase(entityName)}.repository.ts`),
+  writeFileSync14(
+    join22(fnDir, `src/server/repositories/${toKebabCase(entityName)}.repository.ts`),
     content
   );
 }
 function generateRepositoriesIndex(fnDir, entities) {
   const exports = entities.map((entity) => `export * from './${toKebabCase(entity)}.repository';`).join("\n");
-  writeFileSync13(join21(fnDir, "src/server/repositories/index.ts"), exports + "\n");
+  writeFileSync14(join22(fnDir, "src/server/repositories/index.ts"), exports + "\n");
 }
 // src/commands/generate/generators/route.ts
-import { join as join22 } from "path";
-import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync14 } from "fs";
+import { join as join23 } from "path";
+import { mkdirSync as mkdirSync4, writeFileSync as writeFileSync15 } from "fs";
 function generateRoute(fnDir, entityName) {
   const pascalName = toPascalCase(entityName);
   const repoName = `${entityName}Repository`;
@@ -4249,29 +4564,29 @@ function generateRoute(fnDir, entityName) {
     REPO_NAME: repoName,
     KEBAB_NAME: kebabName
   });
-  const routeDir = join22(fnDir, `src/server/routes/${kebabName}`);
+  const routeDir = join23(fnDir, `src/server/routes/${kebabName}`);
   mkdirSync4(routeDir, { recursive: true });
-  writeFileSync14(join22(routeDir, "index.ts"), content);
+  writeFileSync15(join23(routeDir, "index.ts"), content);
 }
 // src/commands/generate/generators/contract.ts
-import { join as join23 } from "path";
-import { writeFileSync as writeFileSync15 } from "fs";
+import { join as join24 } from "path";
+import { writeFileSync as writeFileSync16 } from "fs";
 function generateContract(fnDir, entityName) {
   const pascalName = toPascalCase(entityName);
   const content = loadTemplate("contract", {
     PASCAL_NAME: pascalName,
     ENTITY_NAME: entityName
   });
-  writeFileSync15(
-    join23(fnDir, `src/lib/contracts/${toKebabCase(entityName)}.ts`),
+  writeFileSync16(
+    join24(fnDir, `src/lib/contracts/${toKebabCase(entityName)}.ts`),
     content
   );
 }
 // src/commands/generate/generators/index-files.ts
-import { join as join24 } from "path";
-import { writeFileSync as writeFileSync16 } from "fs";
+import { join as join25 } from "path";
+import { writeFileSync as writeFileSync17 } from "fs";
 function generateMainIndex(fnDir, fnName) {
   const content = `/**
  * @spfn/${fnName}
@@ -4297,7 +4612,7 @@ export * from '@/lib/types/index';
 export * from '@/server/entities/index';
 `;
-  writeFileSync16(join24(fnDir, "src/index.ts"), content);
+  writeFileSync17(join25(fnDir, "src/index.ts"), content);
 }
 function generateServerIndex(fnDir) {
   const content = `/**
@@ -4332,7 +4647,7 @@ export * from '@/server/repositories/index';
 // TODO: Export helpers here
 `;
-  writeFileSync16(join24(fnDir, "src/server.ts"), content);
+  writeFileSync17(join25(fnDir, "src/server.ts"), content);
 }
 function generateClientIndex(fnDir) {
   const content = `/**
@@ -4365,7 +4680,7 @@ export * from './client/store';
 export * from './client/components';
 `;
-  writeFileSync16(join24(fnDir, "src/client.ts"), content);
+  writeFileSync17(join25(fnDir, "src/client.ts"), content);
 }
 function generateTypesFile(fnDir, fnName) {
   const content = `/**
@@ -4377,7 +4692,7 @@ function generateTypesFile(fnDir, fnName) {
 export * from '@/lib/types/index';
 `;
-  writeFileSync16(join24(fnDir, "src/types.ts"), content);
+  writeFileSync17(join25(fnDir, "src/types.ts"), content);
 }
 // src/commands/generate/generators/structure.ts
@@ -4399,7 +4714,7 @@ async function generateFunctionStructure(options) {
     "src/client/store",
     "src/client/components"
   ];
-  dirs.forEach((dir) => mkdirSync5(join25(fnDir, dir), { recursive: true }));
+  dirs.forEach((dir) => mkdirSync5(join26(fnDir, dir), { recursive: true }));
   generatePackageJson(fnDir, scope, fnName, description);
   generateTsConfig(fnDir);
   generateTsupConfig(fnDir);
@@ -4419,15 +4734,15 @@ async function generateFunctionStructure(options) {
     generateEntitiesIndex(fnDir, entities);
     generateRepositoriesIndex(fnDir, entities);
   } else {
-    writeFileSync17(join25(fnDir, "src/server/entities/index.ts"), "// Export your entities here\nexport {}\n");
-    writeFileSync17(join25(fnDir, "src/server/repositories/index.ts"), "// Export your repositories here\nexport {}\n");
-  }
-  writeFileSync17(join25(fnDir, "src/client/hooks/index.ts"), "/**\n * Client Hooks\n */\n\n// TODO: Add hooks (e.g., useAuth, useData, etc.)\nexport {}\n");
-  writeFileSync17(join25(fnDir, "src/client/store/index.ts"), "/**\n * Client Store\n */\n\n// TODO: Add Zustand store if needed\nexport {}\n");
-  writeFileSync17(join25(fnDir, "src/client/components/index.ts"), "/**\n * Client Components\n */\n\n// TODO: Add React components\nexport {}\n");
-  writeFileSync17(join25(fnDir, "src/client/index.ts"), "/**\n * Client Module Entry\n */\n\nexport * from './hooks';\nexport * from './store';\nexport * from './components';\n");
-  writeFileSync17(join25(fnDir, "src/lib/types/index.ts"), "/**\n * Shared Type Definitions\n */\n\n// Add your shared types here\nexport {}\n");
-  writeFileSync17(join25(fnDir, "src/lib/contracts/index.ts"), "/**\n * API Contracts\n */\n\n// Export your contracts here\nexport {}\n");
+    writeFileSync18(join26(fnDir, "src/server/entities/index.ts"), "// Export your entities here\nexport {}\n");
+    writeFileSync18(join26(fnDir, "src/server/repositories/index.ts"), "// Export your repositories here\nexport {}\n");
+  }
+  writeFileSync18(join26(fnDir, "src/client/hooks/index.ts"), "/**\n * Client Hooks\n */\n\n// TODO: Add hooks (e.g., useAuth, useData, etc.)\nexport {}\n");
+  writeFileSync18(join26(fnDir, "src/client/store/index.ts"), "/**\n * Client Store\n */\n\n// TODO: Add Zustand store if needed\nexport {}\n");
+  writeFileSync18(join26(fnDir, "src/client/components/index.ts"), "/**\n * Client Components\n */\n\n// TODO: Add React components\nexport {}\n");
+  writeFileSync18(join26(fnDir, "src/client/index.ts"), "/**\n * Client Module Entry\n */\n\nexport * from './hooks';\nexport * from './store';\nexport * from './components';\n");
+  writeFileSync18(join26(fnDir, "src/lib/types/index.ts"), "/**\n * Shared Type Definitions\n */\n\n// Add your shared types here\nexport {}\n");
+  writeFileSync18(join26(fnDir, "src/lib/contracts/index.ts"), "/**\n * API Contracts\n */\n\n// Export your contracts here\nexport {}\n");
   generateMainIndex(fnDir, fnName);
   generateServerIndex(fnDir);
   generateClientIndex(fnDir);
@@ -4451,8 +4766,8 @@ async function generateFunction(name, options) {
     logger.error("Function name is required");
     process.exit(1);
   }
-  const fnDir = join26(cwd, fnName);
-  if (existsSync23(fnDir)) {
+  const fnDir = join27(cwd, fnName);
+  if (existsSync24(fnDir)) {
     logger.error(`Directory ${fnName} already exists at ${fnDir}`);
     process.exit(1);
   }
@@ -4497,13 +4812,13 @@ async function generateFunction(name, options) {
     });
     spinner.succeed("Function structure generated");
     console.log("");
-    logger.success(`\u2728 Package ${chalk25.cyan(`${scope}/${fnName}`)} created successfully!
+    logger.success(`\u2728 Package ${chalk27.cyan(`${scope}/${fnName}`)} created successfully!
 `);
-    logger.info(chalk25.bold("\u{1F4DA} Next steps:"));
-    console.log(`  ${chalk25.gray("1.")} cd ${fnName}`);
-    console.log(`  ${chalk25.gray("2.")} pnpm install ${chalk25.dim("(in monorepo root)")}`);
-    console.log(`  ${chalk25.gray("3.")} pnpm build`);
-    console.log(`  ${chalk25.gray("4.")} ${chalk25.dim("Use the package in your app")}`);
+    logger.info(chalk27.bold("\u{1F4DA} Next steps:"));
+    console.log(`  ${chalk27.gray("1.")} cd ${fnName}`);
+    console.log(`  ${chalk27.gray("2.")} pnpm install ${chalk27.dim("(in monorepo root)")}`);
+    console.log(`  ${chalk27.gray("3.")} pnpm build`);
+    console.log(`  ${chalk27.gray("4.")} ${chalk27.dim("Use the package in your app")}`);
     console.log("");
   } catch (error) {
     spinner.fail("Failed to generate function");
@@ -4516,8 +4831,8 @@ generateCommand.command("fn").description("Generate a new SPFN function module")
 // src/commands/env.ts
 import { Command as Command12 } from "commander";
-import chalk26 from "chalk";
-import { existsSync as existsSync24, readFileSync as readFileSync8, writeFileSync as writeFileSync18 } from "fs";
+import chalk28 from "chalk";
+import { existsSync as existsSync25, readFileSync as readFileSync9, writeFileSync as writeFileSync19 } from "fs";
 import { resolve } from "path";
 import { parse } from "dotenv";
 var VALID_ENVS = ["local", "development", "staging", "production", "test"];
@@ -4565,26 +4880,26 @@ async function loadEnvSchema(packageName) {
 }
 function formatType(type) {
   const typeColors = {
-    string: chalk26.green,
-    number: chalk26.blue,
-    boolean: chalk26.yellow,
-    url: chalk26.cyan,
-    enum: chalk26.magenta,
-    json: chalk26.red
+    string: chalk28.green,
+    number: chalk28.blue,
+    boolean: chalk28.yellow,
+    url: chalk28.cyan,
+    enum: chalk28.magenta,
+    json: chalk28.red
   };
-  return (typeColors[type] || chalk26.white)(type);
+  return (typeColors[type] || chalk28.white)(type);
 }
 function formatDefault(value, type) {
   if (value === void 0) {
-    return chalk26.dim("(none)");
+    return chalk28.dim("(none)");
   }
   if (type === "string" || type === "url") {
-    return chalk26.green(`"${value}"`);
+    return chalk28.green(`"${value}"`);
   }
   if (type === "boolean") {
-    return value ? chalk26.green("true") : chalk26.red("false");
+    return value ? chalk28.green("true") : chalk28.red("false");
   }
-  return chalk26.cyan(String(value));
+  return chalk28.cyan(String(value));
 }
 async function listEnvVars(options) {
   const packageName = options.package || "@spfn/core";
@@ -4598,28 +4913,28 @@ async function listEnvVars(options) {
         acc[target].push([key, schema]);
         return acc;
       }, {});
-      console.log(chalk26.blue.bold(`
+      console.log(chalk28.blue.bold(`
 \u{1F4CB} Environment Variables by File (${packageName})
 `));
       for (const [file, vars] of Object.entries(grouped)) {
-        console.log(chalk26.bold.magenta(`
+        console.log(chalk28.bold.magenta(`
 ${file}`));
-        console.log(chalk26.dim("\u2500".repeat(50)));
+        console.log(chalk28.dim("\u2500".repeat(50)));
         for (const [key, schema] of vars) {
           printEnvVar(key, schema);
         }
       }
     } else {
-      console.log(chalk26.blue.bold(`
+      console.log(chalk28.blue.bold(`
 \u{1F4CB} Environment Variables (${packageName})
 `));
       for (const [key, schema] of allVars) {
         printEnvVar(key, schema, true);
       }
     }
-    console.log(chalk26.dim("\n\u{1F4A1} Tip: Use `spfn env init` to generate .env template files\n"));
+    console.log(chalk28.dim("\n\u{1F4A1} Tip: Use `spfn env init` to generate .env template files\n"));
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -4627,17 +4942,17 @@ ${file}`));
 }
 function printEnvVar(key, schema, showFile = false) {
   const typeStr = formatType(schema.type);
-  const requiredStr = schema.required || schema.default !== void 0 ? chalk26.red("[required]") : chalk26.dim("[optional]");
-  const sensitiveStr = schema.sensitive ? chalk26.yellow(" [sensitive]") : "";
-  const fileStr = showFile ? chalk26.dim(` \u2192 ${getTargetFile(schema)}`) : "";
-  console.log(`${chalk26.bold.cyan(key)} ${chalk26.dim("(")}${typeStr}${chalk26.dim(")")} ${requiredStr}${sensitiveStr}${fileStr}`);
-  console.log(`  ${chalk26.dim(schema.description)}`);
+  const requiredStr = schema.required || schema.default !== void 0 ? chalk28.red("[required]") : chalk28.dim("[optional]");
+  const sensitiveStr = schema.sensitive ? chalk28.yellow(" [sensitive]") : "";
+  const fileStr = showFile ? chalk28.dim(` \u2192 ${getTargetFile(schema)}`) : "";
+  console.log(`${chalk28.bold.cyan(key)} ${chalk28.dim("(")}${typeStr}${chalk28.dim(")")} ${requiredStr}${sensitiveStr}${fileStr}`);
+  console.log(`  ${chalk28.dim(schema.description)}`);
   if (schema.default !== void 0) {
-    console.log(`  ${chalk26.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
+    console.log(`  ${chalk28.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
   }
   if (schema.examples && schema.examples.length > 0) {
     const exampleStr = schema.examples.map((ex) => formatDefault(ex, schema.type)).join(", ");
-    console.log(`  ${chalk26.dim("Examples:")} ${exampleStr}`);
+    console.log(`  ${chalk28.dim("Examples:")} ${exampleStr}`);
   }
   console.log();
 }
@@ -4645,7 +4960,7 @@ async function showEnvStats(options) {
   const packageName = options.package || "@spfn/core";
   try {
     const envSchema = await loadEnvSchema(packageName);
-    console.log(chalk26.blue.bold(`
+    console.log(chalk28.blue.bold(`
 \u{1F4CA} Environment Variable Statistics (${packageName})
 `));
     const allVars = Object.entries(envSchema);
@@ -4667,24 +4982,24 @@ async function showEnvStats(options) {
       acc[file] = (acc[file] || 0) + 1;
       return acc;
     }, {});
-    console.log(`${chalk26.bold("Total variables:")} ${chalk26.cyan(allVars.length)}`);
-    console.log(`${chalk26.bold("Required:")} ${chalk26.red(required.length)}`);
-    console.log(`${chalk26.bold("Optional:")} ${chalk26.dim(optional.length)}`);
-    console.log(`${chalk26.bold("Sensitive:")} ${chalk26.yellow(sensitive.length)}`);
-    console.log(chalk26.bold("\nBy Target:"));
-    console.log(`  ${chalk26.blue("Next.js accessible:")} ${chalk26.cyan(nextjsVars.length)}`);
-    console.log(`  ${chalk26.magenta("SPFN server only:")} ${chalk26.cyan(serverOnlyVars.length)}`);
-    console.log(chalk26.bold("\nBy File:"));
+    console.log(`${chalk28.bold("Total variables:")} ${chalk28.cyan(allVars.length)}`);
+    console.log(`${chalk28.bold("Required:")} ${chalk28.red(required.length)}`);
+    console.log(`${chalk28.bold("Optional:")} ${chalk28.dim(optional.length)}`);
+    console.log(`${chalk28.bold("Sensitive:")} ${chalk28.yellow(sensitive.length)}`);
+    console.log(chalk28.bold("\nBy Target:"));
+    console.log(`  ${chalk28.blue("Next.js accessible:")} ${chalk28.cyan(nextjsVars.length)}`);
+    console.log(`  ${chalk28.magenta("SPFN server only:")} ${chalk28.cyan(serverOnlyVars.length)}`);
+    console.log(chalk28.bold("\nBy File:"));
     for (const [file, count] of Object.entries(fileCount)) {
-      console.log(`  ${chalk26.dim(file)}: ${chalk26.cyan(count)}`);
+      console.log(`  ${chalk28.dim(file)}: ${chalk28.cyan(count)}`);
     }
-    console.log(chalk26.bold("\nBy Type:"));
+    console.log(chalk28.bold("\nBy Type:"));
     for (const [type, count] of Object.entries(typeCount)) {
-      console.log(`  ${formatType(type)}: ${chalk26.cyan(count)}`);
+      console.log(`  ${formatType(type)}: ${chalk28.cyan(count)}`);
     }
     console.log();
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -4704,26 +5019,26 @@ async function searchEnvVars(query, options) {
       }
     }
     if (results.length === 0) {
-      console.log(chalk26.yellow(`
+      console.log(chalk28.yellow(`
 \u26A0\uFE0F  No environment variables found matching "${query}"
 `));
       return;
     }
-    console.log(chalk26.blue.bold(`
+    console.log(chalk28.blue.bold(`
 \u{1F50D} Found ${results.length} environment variable(s) matching "${query}"
 `));
     for (const [key, schema] of results) {
       const typeStr = formatType(schema.type);
-      const requiredStr = schema.required || schema.default !== void 0 ? chalk26.red("[required]") : chalk26.dim("[optional]");
-      console.log(`${chalk26.bold.cyan(key)} ${chalk26.dim("(")}${typeStr}${chalk26.dim(")")} ${requiredStr}`);
-      console.log(`  ${chalk26.dim(schema.description)}`);
+      const requiredStr = schema.required || schema.default !== void 0 ? chalk28.red("[required]") : chalk28.dim("[optional]");
+      console.log(`${chalk28.bold.cyan(key)} ${chalk28.dim("(")}${typeStr}${chalk28.dim(")")} ${requiredStr}`);
+      console.log(`  ${chalk28.dim(schema.description)}`);
       if (schema.default !== void 0) {
-        console.log(`  ${chalk26.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
+        console.log(`  ${chalk28.dim("Default:")} ${formatDefault(schema.default, schema.type)}`);
       }
       console.log();
     }
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -4735,9 +5050,9 @@ envCommand.command("stats").description("Show environment variable statistics").
 envCommand.command("search").description("Search environment variables").argument("<query>", "Search query (matches key or description)").option("-p, --package <package>", "Package name to read env schema from", "@spfn/core").action(searchEnvVars);
 function validateEnvOption(envValue) {
   if (!VALID_ENVS.includes(envValue)) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C Invalid environment: "${envValue}"`));
-    console.log(chalk26.dim(`   Valid values: ${VALID_ENVS.join(", ")}
+    console.log(chalk28.dim(`   Valid values: ${VALID_ENVS.join(", ")}
 `));
     process.exit(1);
   }
@@ -4758,8 +5073,8 @@ async function initEnvFiles(options) {
       return acc;
     }, {});
     if (targetEnv) {
-      console.log(chalk26.blue.bold(`
-\u{1F680} Generating .env template files for ${chalk26.cyan(targetEnv)} environment
+      console.log(chalk28.blue.bold(`
+\u{1F680} Generating .env template files for ${chalk28.cyan(targetEnv)} environment
 `));
       const envSpecificFiles = {};
       const committedVars = allVars.filter(([_, schema]) => !schema.sensitive);
@@ -4775,25 +5090,25 @@ async function initEnvFiles(options) {
         writeEnvTemplate(cwd, file, vars, options.force ?? false);
       }
     } else {
-      console.log(chalk26.blue.bold(`
+      console.log(chalk28.blue.bold(`
 \u{1F680} Generating .env template files
 `));
       for (const [file, vars] of Object.entries(grouped)) {
         writeEnvTemplate(cwd, file, vars, options.force ?? false);
       }
     }
-    console.log(chalk26.dim("\n\u{1F4A1} Copy .example files to create your actual .env files:"));
-    console.log(chalk26.dim("   cp .env.example .env"));
-    console.log(chalk26.dim("   cp .env.local.example .env.local"));
-    console.log(chalk26.dim("   cp .env.server.example .env.server"));
-    console.log(chalk26.dim("   cp .env.server.local.example .env.server.local"));
+    console.log(chalk28.dim("\n\u{1F4A1} Copy .example files to create your actual .env files:"));
+    console.log(chalk28.dim("   cp .env.example .env"));
+    console.log(chalk28.dim("   cp .env.local.example .env.local"));
+    console.log(chalk28.dim("   cp .env.server.example .env.server"));
+    console.log(chalk28.dim("   cp .env.server.local.example .env.server.local"));
     if (targetEnv) {
-      console.log(chalk26.dim(`   cp .env.${targetEnv}.example .env.${targetEnv}`));
-      console.log(chalk26.dim(`   cp .env.${targetEnv}.local.example .env.${targetEnv}.local`));
+      console.log(chalk28.dim(`   cp .env.${targetEnv}.example .env.${targetEnv}`));
+      console.log(chalk28.dim(`   cp .env.${targetEnv}.local.example .env.${targetEnv}.local`));
     }
     console.log("");
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -4801,12 +5116,12 @@ async function initEnvFiles(options) {
 }
 function writeEnvTemplate(cwd, file, vars, force) {
   const filePath = resolve(cwd, file);
-  if (existsSync24(filePath) && !force) {
-    console.log(chalk26.yellow(`  \u23ED\uFE0F  ${file} already exists (use --force to overwrite)`));
+  if (existsSync25(filePath) && !force) {
+    console.log(chalk28.yellow(`  \u23ED\uFE0F  ${file} already exists (use --force to overwrite)`));
     return;
   }
-  writeFileSync18(filePath, generateEnvFileContent(vars), "utf-8");
-  console.log(chalk26.green(`  \u2705 ${file} (${vars.length} variables)`));
+  writeFileSync19(filePath, generateEnvFileContent(vars), "utf-8");
+  console.log(chalk28.green(`  \u2705 ${file} (${vars.length} variables)`));
 }
 function generateEnvFileContent(vars) {
   const lines = [
@@ -4841,7 +5156,7 @@ async function checkEnvFiles(options) {
     const envSchema = await loadEnvSchema(packageName);
     const allVars = Object.entries(envSchema);
     const envLabel = targetEnv ? ` (${targetEnv})` : "";
-    console.log(chalk26.blue.bold(`
+    console.log(chalk28.blue.bold(`
 \u{1F50D} Checking .env files against schema${envLabel}
 `));
     const filesToCheck = targetEnv ? getEnvFilesForEnvironment(targetEnv) : [...BASE_ENV_FILES.nextjs, ...BASE_ENV_FILES.server];
@@ -4850,15 +5165,15 @@ async function checkEnvFiles(options) {
     const warnings = [];
     for (const file of filesToCheck) {
       const filePath = resolve(cwd, file);
-      if (!existsSync24(filePath)) {
+      if (!existsSync25(filePath)) {
         continue;
       }
-      const content = readFileSync8(filePath, "utf-8");
+      const content = readFileSync9(filePath, "utf-8");
       const parsed = parse(content);
       for (const [key, value] of Object.entries(parsed)) {
         loadedEnv[key] = { value: value || "", file };
       }
-      console.log(chalk26.dim(`  \u{1F4C4} ${file} loaded`));
+      console.log(chalk28.dim(`  \u{1F4C4} ${file} loaded`));
     }
     console.log("");
     for (const [key, schema] of allVars) {
@@ -4866,7 +5181,7 @@ async function checkEnvFiles(options) {
       const found = loadedEnv[key];
       if (!found) {
         if (schema.required && schema.default === void 0) {
-          issues.push(`${chalk26.red("\u2717")} ${chalk26.cyan(key)} is required but not found in any .env file`);
+          issues.push(`${chalk28.red("\u2717")} ${chalk28.cyan(key)} is required but not found in any .env file`);
         }
         continue;
       }
@@ -4876,11 +5191,11 @@ async function checkEnvFiles(options) {
       if (!shouldBeNextjs && isNextjsFile && !isServerFile) {
         if (schema.sensitive) {
           issues.push(
-            `${chalk26.red("\u2717")} ${chalk26.cyan(key)} is sensitive and should be in ${chalk26.magenta(expectedFile)}, but found in ${chalk26.yellow(found.file)} (security risk!)`
+            `${chalk28.red("\u2717")} ${chalk28.cyan(key)} is sensitive and should be in ${chalk28.magenta(expectedFile)}, but found in ${chalk28.yellow(found.file)} (security risk!)`
           );
         } else {
           warnings.push(
-            `${chalk26.yellow("\u26A0")} ${chalk26.cyan(key)} should be in ${chalk26.magenta(expectedFile)}, but found in ${chalk26.dim(found.file)}`
+            `${chalk28.yellow("\u26A0")} ${chalk28.cyan(key)} should be in ${chalk28.magenta(expectedFile)}, but found in ${chalk28.dim(found.file)}`
           );
         }
       }
@@ -4888,34 +5203,34 @@ async function checkEnvFiles(options) {
     for (const [key, { file }] of Object.entries(loadedEnv)) {
       const inSchema = allVars.some(([k]) => k === key);
       if (!inSchema) {
-        warnings.push(`${chalk26.yellow("\u26A0")} ${chalk26.cyan(key)} in ${chalk26.dim(file)} is not in schema`);
+        warnings.push(`${chalk28.yellow("\u26A0")} ${chalk28.cyan(key)} in ${chalk28.dim(file)} is not in schema`);
       }
     }
     if (issues.length > 0) {
-      console.log(chalk26.red.bold("Issues:"));
+      console.log(chalk28.red.bold("Issues:"));
       for (const issue of issues) {
         console.log(`  ${issue}`);
       }
       console.log("");
     }
     if (warnings.length > 0) {
-      console.log(chalk26.yellow.bold("Warnings:"));
+      console.log(chalk28.yellow.bold("Warnings:"));
       for (const warning of warnings) {
         console.log(`  ${warning}`);
       }
       console.log("");
     }
     if (issues.length === 0 && warnings.length === 0) {
-      console.log(chalk26.green("\u2705 All environment variables are correctly configured!\n"));
+      console.log(chalk28.green("\u2705 All environment variables are correctly configured!\n"));
     } else {
-      console.log(chalk26.dim(`Found ${issues.length} issue(s) and ${warnings.length} warning(s)
+      console.log(chalk28.dim(`Found ${issues.length} issue(s) and ${warnings.length} warning(s)
 `));
       if (issues.length > 0) {
         process.exit(1);
       }
     }
   } catch (error) {
-    console.error(chalk26.red(`
+    console.error(chalk28.red(`
 \u274C ${error instanceof Error ? error.message : "Unknown error"}
 `));
     process.exit(1);
@@ -4927,17 +5242,17 @@ async function validateEnvVars(options) {
   const packages = options.packages || ["@spfn/core"];
   const targetEnv = options.env ? validateEnvOption(options.env) : void 0;
   if (targetEnv) {
-    const { loadEnv: loadEnv6 } = await import("@spfn/core/env/loader");
-    const result = loadEnv6({ nodeEnv: targetEnv });
-    console.log(chalk26.blue.bold(`
-\u{1F50D} Validating environment variables for ${chalk26.cyan(targetEnv)}
+    const { loadEnv: loadEnv8 } = await import("@spfn/core/env/loader");
+    const result = loadEnv8({ nodeEnv: targetEnv });
+    console.log(chalk28.blue.bold(`
+\u{1F50D} Validating environment variables for ${chalk28.cyan(targetEnv)}
 `));
     if (result.loadedFiles.length > 0) {
-      console.log(chalk26.dim(`  Loaded: ${result.loadedFiles.join(", ")}`));
+      console.log(chalk28.dim(`  Loaded: ${result.loadedFiles.join(", ")}`));
     }
     console.log("");
   } else {
-    console.log(chalk26.blue.bold(`
+    console.log(chalk28.blue.bold(`
 \u{1F50D} Validating environment variables
 `));
   }
@@ -4945,7 +5260,7 @@ async function validateEnvVars(options) {
   const allWarnings = [];
   for (const packageName of packages) {
     try {
-      console.log(chalk26.dim(`  \u{1F4E6} ${packageName}`));
+      console.log(chalk28.dim(`  \u{1F4E6} ${packageName}`));
       const envSchema = await loadEnvSchema(packageName);
       const { createEnvRegistry } = await import("@spfn/core/env");
       const registry = createEnvRegistry(envSchema);
@@ -4958,10 +5273,10 @@ async function validateEnvVars(options) {
       }
     } catch (error) {
       if (error instanceof Error && error.message.includes("does not export envSchema")) {
-        console.log(chalk26.dim(`    \u23ED\uFE0F  No envSchema exported, skipping`));
+        console.log(chalk28.dim(`    \u23ED\uFE0F  No envSchema exported, skipping`));
         continue;
       }
-      console.error(chalk26.red(`    \u274C Failed to load: ${error instanceof Error ? error.message : String(error)}`));
+      console.error(chalk28.red(`    \u274C Failed to load: ${error instanceof Error ? error.message : String(error)}`));
       if (options.strict) {
         process.exit(1);
       }
@@ -4969,32 +5284,32 @@ async function validateEnvVars(options) {
   }
   console.log("");
   if (allErrors.length > 0) {
-    console.log(chalk26.red.bold(`\u274C Validation Errors (${allErrors.length}):
+    console.log(chalk28.red.bold(`\u274C Validation Errors (${allErrors.length}):
 `));
     for (const error of allErrors) {
-      console.log(`  ${chalk26.red("\u2717")} ${chalk26.cyan(error.key)}`);
-      console.log(`    ${chalk26.dim(error.message)}`);
-      console.log(`    ${chalk26.dim(`from ${error.package}`)}`);
+      console.log(`  ${chalk28.red("\u2717")} ${chalk28.cyan(error.key)}`);
+      console.log(`    ${chalk28.dim(error.message)}`);
+      console.log(`    ${chalk28.dim(`from ${error.package}`)}`);
       console.log("");
     }
   }
   if (allWarnings.length > 0) {
-    console.log(chalk26.yellow.bold(`\u26A0\uFE0F  Warnings (${allWarnings.length}):
+    console.log(chalk28.yellow.bold(`\u26A0\uFE0F  Warnings (${allWarnings.length}):
 `));
     for (const warning of allWarnings) {
-      console.log(`  ${chalk26.yellow("\u26A0")} ${chalk26.cyan(warning.key)}`);
-      console.log(`    ${chalk26.dim(warning.message)}`);
+      console.log(`  ${chalk28.yellow("\u26A0")} ${chalk28.cyan(warning.key)}`);
+      console.log(`    ${chalk28.dim(warning.message)}`);
       console.log("");
     }
   }
   if (allErrors.length === 0 && allWarnings.length === 0) {
-    console.log(chalk26.green.bold("\u2705 All environment variables are valid!\n"));
+    console.log(chalk28.green.bold("\u2705 All environment variables are valid!\n"));
   } else if (allErrors.length === 0) {
-    console.log(chalk26.green("\u2705 No errors found."));
-    console.log(chalk26.yellow(`\u26A0\uFE0F  ${allWarnings.length} warning(s) found.
+    console.log(chalk28.green("\u2705 No errors found."));
+    console.log(chalk28.yellow(`\u26A0\uFE0F  ${allWarnings.length} warning(s) found.
 `));
   } else {
-    console.log(chalk26.red(`
+    console.log(chalk28.red(`
 \u274C Validation failed with ${allErrors.length} error(s)
 `));
     process.exit(1);