@tthr/cli 0.0.4 → 0.0.5

package/dist/index.js

@@ -4,11 +4,11 @@
 import { Command } from "commander";
 
 // src/commands/init.ts
-import chalk2 from "chalk";
-import ora from "ora";
+import chalk3 from "chalk";
+import ora2 from "ora";
 import prompts from "prompts";
-import fs2 from "fs-extra";
-import path2 from "path";
+import fs3 from "fs-extra";
+import path3 from "path";
 import { execSync } from "child_process";
 
 // src/utils/auth.ts
@@ -54,9 +54,284 @@ async function clearCredentials() {
   }
 }
 
-// src/commands/init.ts
+// src/commands/deploy.ts
+import chalk2 from "chalk";
+import ora from "ora";
+import fs2 from "fs-extra";
+import path2 from "path";
 var isDev = process.env.NODE_ENV === "development" || process.env.TETHER_DEV === "true";
 var API_URL = isDev ? "http://localhost:3001/api/v1" : "https://tthr.io/api/v1";
+async function deployCommand(options) {
+  const credentials = await requireAuth();
+  const configPath = path2.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs2.pathExists(configPath)) {
+    console.log(chalk2.red("\nError: Not a Tether project"));
+    console.log(chalk2.dim("Run `tthr init` to create a new project\n"));
+    process.exit(1);
+  }
+  const envPath = path2.resolve(process.cwd(), ".env");
+  let projectId;
+  if (await fs2.pathExists(envPath)) {
+    const envContent = await fs2.readFile(envPath, "utf-8");
+    const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
+    projectId = match?.[1]?.trim();
+  }
+  if (!projectId) {
+    console.log(chalk2.red("\nError: Project ID not found"));
+    console.log(chalk2.dim("Make sure TETHER_PROJECT_ID is set in your .env file\n"));
+    process.exit(1);
+  }
+  console.log(chalk2.bold("\n\u26A1 Deploying to Tether\n"));
+  console.log(chalk2.dim(`  Project: ${projectId}`));
+  console.log(chalk2.dim(`  API: ${API_URL}
+`));
+  const deploySchema = options.schema || !options.schema && !options.functions;
+  const deployFunctions = options.functions || !options.schema && !options.functions;
+  if (deploySchema) {
+    await deploySchemaToServer(projectId, credentials.accessToken, options.dryRun);
+  }
+  if (deployFunctions) {
+    await deployFunctionsToServer(projectId, credentials.accessToken, options.dryRun);
+  }
+  console.log(chalk2.green("\n\u2713 Deployment complete\n"));
+}
+async function deploySchemaToServer(projectId, token, dryRun) {
+  const spinner = ora("Reading schema...").start();
+  try {
+    const schemaPath = path2.resolve(process.cwd(), "tether", "schema.ts");
+    if (!await fs2.pathExists(schemaPath)) {
+      spinner.warn("No schema file found");
+      console.log(chalk2.dim("  Create tether/schema.ts to define your database schema\n"));
+      return;
+    }
+    const schemaSource = await fs2.readFile(schemaPath, "utf-8");
+    const tables = parseSchema(schemaSource);
+    spinner.text = `Found ${tables.length} table(s)`;
+    if (dryRun) {
+      spinner.info("Dry run - would deploy schema:");
+      for (const table of tables) {
+        console.log(chalk2.dim(`  - ${table.name}`));
+      }
+      return;
+    }
+    const sql = generateSchemaSQL(tables);
+    spinner.text = "Deploying schema...";
+    const response = await fetch(`${API_URL}/${projectId}/deploy/schema`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        sql,
+        tables: tables.map((t) => t.name)
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    spinner.succeed(`Schema deployed (${tables.length} table(s))`);
+  } catch (error) {
+    spinner.fail("Failed to deploy schema");
+    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
+  }
+}
+async function deployFunctionsToServer(projectId, token, dryRun) {
+  const spinner = ora("Reading functions...").start();
+  try {
+    const functionsDir = path2.resolve(process.cwd(), "tether", "functions");
+    if (!await fs2.pathExists(functionsDir)) {
+      spinner.warn("No functions directory found");
+      console.log(chalk2.dim("  Create tether/functions/ to define your API functions\n"));
+      return;
+    }
+    const files = await fs2.readdir(functionsDir);
+    const tsFiles = files.filter((f) => f.endsWith(".ts"));
+    if (tsFiles.length === 0) {
+      spinner.info("No function files found");
+      return;
+    }
+    const functions = [];
+    for (const file of tsFiles) {
+      const filePath = path2.join(functionsDir, file);
+      const source = await fs2.readFile(filePath, "utf-8");
+      const moduleName = file.replace(".ts", "");
+      const parsedFunctions = parseFunctions(moduleName, source);
+      functions.push(...parsedFunctions);
+    }
+    spinner.text = `Found ${functions.length} function(s)`;
+    if (dryRun) {
+      spinner.info("Dry run - would deploy functions:");
+      for (const fn of functions) {
+        const icon = fn.type === "query" ? "\u{1F50D}" : fn.type === "mutation" ? "\u270F\uFE0F" : "\u26A1";
+        console.log(chalk2.dim(`  ${icon} ${fn.name} (${fn.type})`));
+      }
+      return;
+    }
+    spinner.text = "Deploying functions...";
+    const response = await fetch(`${API_URL}/${projectId}/deploy/functions`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        "Authorization": `Bearer ${token}`
+      },
+      body: JSON.stringify({
+        functions: functions.map((fn) => ({
+          name: fn.name,
+          type: fn.type,
+          source: fn.source
+        }))
+      })
+    });
+    if (!response.ok) {
+      const error = await response.json().catch(() => ({ error: "Unknown error" }));
+      throw new Error(error.error || `HTTP ${response.status}`);
+    }
+    spinner.succeed(`Functions deployed (${functions.length} function(s))`);
+    const queries = functions.filter((f) => f.type === "query");
+    const mutations = functions.filter((f) => f.type === "mutation");
+    const actions = functions.filter((f) => f.type === "action");
+    if (queries.length > 0) {
+      console.log(chalk2.dim(`
+  Queries:`));
+      for (const fn of queries) {
+        console.log(chalk2.dim(`    - ${fn.name}`));
+      }
+    }
+    if (mutations.length > 0) {
+      console.log(chalk2.dim(`
+  Mutations:`));
+      for (const fn of mutations) {
+        console.log(chalk2.dim(`    - ${fn.name}`));
+      }
+    }
+    if (actions.length > 0) {
+      console.log(chalk2.dim(`
+  Actions:`));
+      for (const fn of actions) {
+        console.log(chalk2.dim(`    - ${fn.name}`));
+      }
+    }
+  } catch (error) {
+    spinner.fail("Failed to deploy functions");
+    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
+  }
+}
+function parseSchema(source) {
+  const tables = [];
+  const schemaMatch = source.match(/defineSchema\s*\(\s*\{([\s\S]*)\}\s*\)/);
+  if (!schemaMatch) return tables;
+  const schemaContent = schemaMatch[1];
+  const tableRegex = /(\w+)\s*:\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}/g;
+  let match;
+  while ((match = tableRegex.exec(schemaContent)) !== null) {
+    const tableName = match[1];
+    const columnsContent = match[2];
+    const columns = {};
+    const columnRegex = /(\w+)\s*:\s*(\w+)\s*\(\s*\)([^,\n]*)/g;
+    let colMatch;
+    while ((colMatch = columnRegex.exec(columnsContent)) !== null) {
+      const colName = colMatch[1];
+      const colType = colMatch[2];
+      const modifiers = colMatch[3];
+      columns[colName] = {
+        type: colType,
+        primaryKey: modifiers.includes(".primaryKey()"),
+        notNull: modifiers.includes(".notNull()"),
+        unique: modifiers.includes(".unique()"),
+        hasDefault: modifiers.includes(".default("),
+        references: modifiers.match(/\.references\s*\(\s*['"]([^'"]+)['"]\s*\)/)?.[1]
+      };
+    }
+    tables.push({ name: tableName, columns });
+  }
+  return tables;
+}
+function generateSchemaSQL(tables) {
+  const statements = [];
+  for (const table of tables) {
+    const columnDefs = [];
+    for (const [colName, colDef] of Object.entries(table.columns)) {
+      const def = colDef;
+      let sqlType = "TEXT";
+      switch (def.type) {
+        case "text":
+          sqlType = "TEXT";
+          break;
+        case "integer":
+          sqlType = "INTEGER";
+          break;
+        case "real":
+          sqlType = "REAL";
+          break;
+        case "blob":
+          sqlType = "BLOB";
+          break;
+        case "timestamp":
+          sqlType = "TEXT";
+          break;
+        case "boolean":
+          sqlType = "INTEGER";
+          break;
+        case "json":
+          sqlType = "TEXT";
+          break;
+      }
+      let colSql = `${colName} ${sqlType}`;
+      if (def.primaryKey) colSql += " PRIMARY KEY";
+      if (def.notNull) colSql += " NOT NULL";
+      if (def.unique) colSql += " UNIQUE";
+      if (def.hasDefault && def.type === "timestamp") {
+        colSql += " DEFAULT (datetime('now'))";
+      }
+      if (def.references) {
+        const [refTable, refCol] = def.references.split(".");
+        colSql += ` REFERENCES ${refTable}(${refCol})`;
+      }
+      columnDefs.push(colSql);
+    }
+    statements.push(
+      `CREATE TABLE IF NOT EXISTS ${table.name} (
+  ${columnDefs.join(",\n  ")}
+);`
+    );
+  }
+  return statements.join("\n\n");
+}
+function parseFunctions(moduleName, source) {
+  const functions = [];
+  const exportRegex = /export\s+const\s+(\w+)\s*=\s*(query|mutation|action)\s*\(/g;
+  let match;
+  while ((match = exportRegex.exec(source)) !== null) {
+    const fnName = match[1];
+    const fnType = match[2];
+    const startIndex = match.index + match[0].length;
+    let depth = 1;
+    let endIndex = startIndex;
+    for (let i = startIndex; i < source.length && depth > 0; i++) {
+      const char = source[i];
+      if (char === "(" || char === "{") {
+        depth++;
+      } else if (char === ")" || char === "}") {
+        depth--;
+      }
+      endIndex = i;
+    }
+    const fnBody = source.slice(startIndex, endIndex);
+    functions.push({
+      name: `${moduleName}.${fnName}`,
+      type: fnType,
+      file: `${moduleName}.ts`,
+      source: `${fnType}(${fnBody})`
+    });
+  }
+  return functions;
+}
+
+// src/commands/init.ts
+var isDev2 = process.env.NODE_ENV === "development" || process.env.TETHER_DEV === "true";
+var API_URL2 = isDev2 ? "http://localhost:3001/api/v1" : "https://tthr.io/api/v1";
 async function getLatestVersion(packageName) {
   try {
     const response = await fetch(`https://registry.npmjs.org/${packageName}/latest`);
@@ -71,7 +346,7 @@ async function getLatestVersion(packageName) {
 }
 async function initCommand(name, options) {
   const credentials = await requireAuth();
-  console.log(chalk2.bold("\n\u26A1 Create a new Tether project\n"));
+  console.log(chalk3.bold("\n\u26A1 Create a new Tether project\n"));
   let projectName = name;
   if (!projectName) {
     const response = await prompts({
@@ -82,7 +357,7 @@ async function initCommand(name, options) {
     });
     projectName = response.name;
     if (!projectName) {
-      console.log(chalk2.red("Project name is required"));
+      console.log(chalk3.red("Project name is required"));
       process.exit(1);
     }
   }
@@ -102,8 +377,8 @@ async function initCommand(name, options) {
     });
     template = response.template || "nuxt";
   }
-  const projectPath = path2.resolve(process.cwd(), projectName);
-  if (await fs2.pathExists(projectPath)) {
+  const projectPath = path3.resolve(process.cwd(), projectName);
+  if (await fs3.pathExists(projectPath)) {
     const { overwrite } = await prompts({
       type: "confirm",
       name: "overwrite",
@@ -111,16 +386,16 @@ async function initCommand(name, options) {
       initial: false
     });
     if (!overwrite) {
-      console.log(chalk2.yellow("Cancelled"));
+      console.log(chalk3.yellow("Cancelled"));
       process.exit(0);
     }
-    await fs2.remove(projectPath);
+    await fs3.remove(projectPath);
   }
-  const spinner = ora("Creating project on Tether...").start();
+  const spinner = ora2("Creating project on Tether...").start();
   let projectId;
   let apiKey;
   try {
-    const response = await fetch(`${API_URL}/projects`, {
+    const response = await fetch(`${API_URL2}/projects`, {
       method: "POST",
       headers: {
         "Content-Type": "application/json",
@@ -153,33 +428,39 @@ async function initCommand(name, options) {
     await installTetherPackages(projectPath, template);
     spinner.text = "Creating demo page...";
     await createDemoPage(projectPath, template);
-    spinner.text = "Running initial migration...";
-    await runInitialMigration(projectPath, projectId, apiKey);
     spinner.succeed("Project created successfully!");
-    console.log("\n" + chalk2.green("\u2713") + " Project created successfully!\n");
+    console.log("");
+    const originalCwd = process.cwd();
+    process.chdir(projectPath);
+    try {
+      await deployCommand({});
+    } finally {
+      process.chdir(originalCwd);
+    }
+    console.log("\n" + chalk3.green("\u2713") + " Project created successfully!\n");
     console.log("Next steps:\n");
-    console.log(chalk2.cyan(`  cd ${projectName}`));
+    console.log(chalk3.cyan(`  cd ${projectName}`));
     if (template === "vanilla") {
-      console.log(chalk2.cyan("  npm install"));
+      console.log(chalk3.cyan("  npm install"));
     }
-    console.log(chalk2.cyan("  npm run dev"));
-    console.log("\n" + chalk2.dim("For more information, visit https://tthr.io/docs\n"));
+    console.log(chalk3.cyan("  npm run dev"));
+    console.log("\n" + chalk3.dim("For more information, visit https://tthr.io/docs\n"));
   } catch (error) {
     spinner.fail("Failed to create project");
-    console.error(chalk2.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk3.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 async function scaffoldNuxtProject(projectName, projectPath, spinner) {
-  const parentDir = path2.dirname(projectPath);
+  const parentDir = path3.dirname(projectPath);
   spinner.stop();
-  console.log(chalk2.dim("\nRunning nuxi init...\n"));
+  console.log(chalk3.dim("\nRunning nuxi init...\n"));
   try {
     execSync(`npx nuxi@latest init ${projectName} --packageManager npm --gitInit false`, {
       cwd: parentDir,
       stdio: "inherit"
     });
-    if (!await fs2.pathExists(path2.join(projectPath, "package.json"))) {
+    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
       throw new Error("Nuxt project was not created successfully - package.json missing");
     }
     spinner.start();
@@ -192,15 +473,15 @@ async function scaffoldNuxtProject(projectName, projectPath, spinner) {
   }
 }
 async function scaffoldNextProject(projectName, projectPath, spinner) {
-  const parentDir = path2.dirname(projectPath);
+  const parentDir = path3.dirname(projectPath);
   spinner.stop();
-  console.log(chalk2.dim("\nRunning create-next-app...\n"));
+  console.log(chalk3.dim("\nRunning create-next-app...\n"));
   try {
     execSync(`npx create-next-app@latest ${projectName} --typescript --eslint --tailwind --src-dir --app --import-alias "@/*" --use-npm`, {
       cwd: parentDir,
       stdio: "inherit"
     });
-    if (!await fs2.pathExists(path2.join(projectPath, "package.json"))) {
+    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
       throw new Error("Next.js project was not created successfully - package.json missing");
     }
     spinner.start();
@@ -213,15 +494,15 @@ async function scaffoldNextProject(projectName, projectPath, spinner) {
   }
 }
 async function scaffoldSvelteKitProject(projectName, projectPath, spinner) {
-  const parentDir = path2.dirname(projectPath);
+  const parentDir = path3.dirname(projectPath);
   spinner.stop();
-  console.log(chalk2.dim("\nRunning sv create...\n"));
+  console.log(chalk3.dim("\nRunning sv create...\n"));
   try {
     execSync(`npx sv create ${projectName} --template minimal --types ts --no-add-ons --no-install`, {
       cwd: parentDir,
       stdio: "inherit"
     });
-    if (!await fs2.pathExists(path2.join(projectPath, "package.json"))) {
+    if (!await fs3.pathExists(path3.join(projectPath, "package.json"))) {
       throw new Error("SvelteKit project was not created successfully - package.json missing");
     }
     spinner.start();
@@ -235,8 +516,8 @@ async function scaffoldSvelteKitProject(projectName, projectPath, spinner) {
 }
 async function scaffoldVanillaProject(projectName, projectPath, spinner) {
   spinner.text = "Creating vanilla TypeScript project...";
-  await fs2.ensureDir(projectPath);
-  await fs2.ensureDir(path2.join(projectPath, "src"));
+  await fs3.ensureDir(projectPath);
+  await fs3.ensureDir(path3.join(projectPath, "src"));
   const packageJson = {
     name: projectName,
     version: "0.0.1",
@@ -253,9 +534,9 @@ async function scaffoldVanillaProject(projectName, projectPath, spinner) {
       "@types/node": "latest"
     }
   };
-  await fs2.writeJSON(path2.join(projectPath, "package.json"), packageJson, { spaces: 2 });
-  await fs2.writeJSON(
-    path2.join(projectPath, "tsconfig.json"),
+  await fs3.writeJSON(path3.join(projectPath, "package.json"), packageJson, { spaces: 2 });
+  await fs3.writeJSON(
+    path3.join(projectPath, "tsconfig.json"),
     {
       compilerOptions: {
         target: "ES2022",
@@ -276,8 +557,8 @@ async function scaffoldVanillaProject(projectName, projectPath, spinner) {
     },
     { spaces: 2 }
   );
-  await fs2.writeFile(
-    path2.join(projectPath, "src", "index.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "src", "index.ts"),
     `import { createClient } from '@tthr/client';
 
 const tether = createClient({
@@ -296,8 +577,8 @@ async function main() {
 main().catch(console.error);
 `
   );
-  await fs2.writeFile(
-    path2.join(projectPath, ".gitignore"),
+  await fs3.writeFile(
+    path3.join(projectPath, ".gitignore"),
     `node_modules/
 dist/
 .env
@@ -307,11 +588,11 @@ dist/
   );
 }
 async function addTetherFiles(projectPath, projectId, apiKey, template) {
-  await fs2.ensureDir(path2.join(projectPath, "tether"));
-  await fs2.ensureDir(path2.join(projectPath, "tether", "functions"));
+  await fs3.ensureDir(path3.join(projectPath, "tether"));
+  await fs3.ensureDir(path3.join(projectPath, "tether", "functions"));
   const configPackage = template === "nuxt" ? "@tthr/vue" : template === "next" ? "@tthr/react" : template === "sveltekit" ? "@tthr/svelte" : "@tthr/client";
-  await fs2.writeFile(
-    path2.join(projectPath, "tether.config.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "tether.config.ts"),
     `import { defineConfig } from '${configPackage}';
 
 export default defineConfig({
@@ -332,8 +613,8 @@ export default defineConfig({
 });
 `
   );
-  await fs2.writeFile(
-    path2.join(projectPath, "tether", "schema.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "tether", "schema.ts"),
     `import { defineSchema, text, integer, timestamp } from '@tthr/schema';
 
 export default defineSchema({
@@ -358,8 +639,8 @@ export default defineSchema({
 });
 `
   );
-  await fs2.writeFile(
-    path2.join(projectPath, "tether", "functions", "posts.ts"),
+  await fs3.writeFile(
+    path3.join(projectPath, "tether", "functions", "posts.ts"),
     `import { query, mutation, z } from '@tthr/server';
 
 // List all posts
@@ -446,30 +727,30 @@ export const remove = mutation({
   );
   const envContent = `# Tether Configuration
 TETHER_PROJECT_ID=${projectId}
-TETHER_URL=${isDev ? "http://localhost:3001" : "https://tthr.io"}
+TETHER_URL=${isDev2 ? "http://localhost:3001" : "https://tthr.io"}
 TETHER_API_KEY=${apiKey}
 `;
-  const envPath = path2.join(projectPath, ".env");
-  if (await fs2.pathExists(envPath)) {
-    const existing = await fs2.readFile(envPath, "utf-8");
-    await fs2.writeFile(envPath, existing + "\n" + envContent);
+  const envPath = path3.join(projectPath, ".env");
+  if (await fs3.pathExists(envPath)) {
+    const existing = await fs3.readFile(envPath, "utf-8");
+    await fs3.writeFile(envPath, existing + "\n" + envContent);
   } else {
-    await fs2.writeFile(envPath, envContent);
+    await fs3.writeFile(envPath, envContent);
   }
-  const gitignorePath = path2.join(projectPath, ".gitignore");
+  const gitignorePath = path3.join(projectPath, ".gitignore");
   const tetherGitignore = `
 # Tether
 _generated/
 .env
 .env.local
 `;
-  if (await fs2.pathExists(gitignorePath)) {
-    const existing = await fs2.readFile(gitignorePath, "utf-8");
+  if (await fs3.pathExists(gitignorePath)) {
+    const existing = await fs3.readFile(gitignorePath, "utf-8");
     if (!existing.includes("_generated/")) {
-      await fs2.writeFile(gitignorePath, existing + tetherGitignore);
+      await fs3.writeFile(gitignorePath, existing + tetherGitignore);
     }
   } else {
-    await fs2.writeFile(gitignorePath, tetherGitignore.trim());
+    await fs3.writeFile(gitignorePath, tetherGitignore.trim());
   }
 }
 async function configureFramework(projectPath, template) {
@@ -482,9 +763,9 @@ async function configureFramework(projectPath, template) {
   }
 }
 async function configureNuxt(projectPath) {
-  const configPath = path2.join(projectPath, "nuxt.config.ts");
-  if (!await fs2.pathExists(configPath)) {
-    await fs2.writeFile(
+  const configPath = path3.join(projectPath, "nuxt.config.ts");
+  if (!await fs3.pathExists(configPath)) {
+    await fs3.writeFile(
       configPath,
       `// https://nuxt.com/docs/api/configuration/nuxt-config
 export default defineNuxtConfig({
@@ -502,7 +783,7 @@ export default defineNuxtConfig({
     );
     return;
   }
-  let config = await fs2.readFile(configPath, "utf-8");
+  let config = await fs3.readFile(configPath, "utf-8");
   if (config.includes("modules:")) {
     config = config.replace(
       /modules:\s*\[/,
@@ -529,11 +810,11 @@ export default defineNuxtConfig({
 `
     );
   }
-  await fs2.writeFile(configPath, config);
+  await fs3.writeFile(configPath, config);
 }
 async function configureNext(projectPath) {
-  const providersPath = path2.join(projectPath, "src", "app", "providers.tsx");
-  await fs2.writeFile(
+  const providersPath = path3.join(projectPath, "src", "app", "providers.tsx");
+  await fs3.writeFile(
     providersPath,
     `'use client';
 
@@ -551,9 +832,9 @@ export function Providers({ children }: { children: React.ReactNode }) {
 }
 `
   );
-  const layoutPath = path2.join(projectPath, "src", "app", "layout.tsx");
-  if (await fs2.pathExists(layoutPath)) {
-    let layout = await fs2.readFile(layoutPath, "utf-8");
+  const layoutPath = path3.join(projectPath, "src", "app", "layout.tsx");
+  if (await fs3.pathExists(layoutPath)) {
+    let layout = await fs3.readFile(layoutPath, "utf-8");
     if (!layout.includes("import { Providers }")) {
       layout = layout.replace(
         /^(import.*\n)+/m,
@@ -566,25 +847,25 @@ export function Providers({ children }: { children: React.ReactNode }) {
         "$1<Providers>$2</Providers>$3"
       );
     }
-    await fs2.writeFile(layoutPath, layout);
+    await fs3.writeFile(layoutPath, layout);
   }
-  const envLocalPath = path2.join(projectPath, ".env.local");
+  const envLocalPath = path3.join(projectPath, ".env.local");
   const nextEnvContent = `# Tether Configuration (client-side)
 NEXT_PUBLIC_TETHER_PROJECT_ID=\${TETHER_PROJECT_ID}
 NEXT_PUBLIC_TETHER_URL=\${TETHER_URL}
 `;
-  if (await fs2.pathExists(envLocalPath)) {
-    const existing = await fs2.readFile(envLocalPath, "utf-8");
-    await fs2.writeFile(envLocalPath, existing + "\n" + nextEnvContent);
+  if (await fs3.pathExists(envLocalPath)) {
+    const existing = await fs3.readFile(envLocalPath, "utf-8");
+    await fs3.writeFile(envLocalPath, existing + "\n" + nextEnvContent);
   } else {
-    await fs2.writeFile(envLocalPath, nextEnvContent);
+    await fs3.writeFile(envLocalPath, nextEnvContent);
   }
 }
 async function configureSvelteKit(projectPath) {
-  const libPath = path2.join(projectPath, "src", "lib");
-  await fs2.ensureDir(libPath);
-  await fs2.writeFile(
-    path2.join(libPath, "tether.ts"),
+  const libPath = path3.join(projectPath, "src", "lib");
+  await fs3.ensureDir(libPath);
+  await fs3.writeFile(
+    path3.join(libPath, "tether.ts"),
     `import { createClient } from '@tthr/svelte';
 import { PUBLIC_TETHER_PROJECT_ID, PUBLIC_TETHER_URL } from '$env/static/public';
 
@@ -594,15 +875,15 @@ export const tether = createClient({
 });
 `
   );
-  const envPath = path2.join(projectPath, ".env");
+  const envPath = path3.join(projectPath, ".env");
   const svelteEnvContent = `# Tether Configuration (public)
 PUBLIC_TETHER_PROJECT_ID=\${TETHER_PROJECT_ID}
 PUBLIC_TETHER_URL=\${TETHER_URL}
 `;
-  if (await fs2.pathExists(envPath)) {
-    const existing = await fs2.readFile(envPath, "utf-8");
+  if (await fs3.pathExists(envPath)) {
+    const existing = await fs3.readFile(envPath, "utf-8");
     if (!existing.includes("PUBLIC_TETHER_")) {
-      await fs2.writeFile(envPath, existing + "\n" + svelteEnvContent);
+      await fs3.writeFile(envPath, existing + "\n" + svelteEnvContent);
     }
   }
 }
@@ -646,15 +927,15 @@ async function installTetherPackages(projectPath, template) {
       stdio: "pipe"
     });
   } catch (error) {
-    console.warn(chalk2.yellow("\nNote: Some Tether packages may not be published yet."));
+    console.warn(chalk3.yellow("\nNote: Some Tether packages may not be published yet."));
   }
 }
 async function createDemoPage(projectPath, template) {
   if (template === "nuxt") {
-    const nuxt4AppVuePath = path2.join(projectPath, "app", "app.vue");
-    const nuxt3AppVuePath = path2.join(projectPath, "app.vue");
-    const appVuePath = await fs2.pathExists(path2.join(projectPath, "app")) ? nuxt4AppVuePath : nuxt3AppVuePath;
-    await fs2.writeFile(
+    const nuxt4AppVuePath = path3.join(projectPath, "app", "app.vue");
+    const nuxt3AppVuePath = path3.join(projectPath, "app.vue");
+    const appVuePath = await fs3.pathExists(path3.join(projectPath, "app")) ? nuxt4AppVuePath : nuxt3AppVuePath;
+    await fs3.writeFile(
       appVuePath,
       `<template>
   <TetherWelcome />
@@ -662,8 +943,8 @@ async function createDemoPage(projectPath, template) {
 `
     );
   } else if (template === "next") {
-    const pagePath = path2.join(projectPath, "src", "app", "page.tsx");
-    await fs2.writeFile(
+    const pagePath = path3.join(projectPath, "src", "app", "page.tsx");
+    await fs3.writeFile(
       pagePath,
       `'use client';
 
@@ -773,8 +1054,8 @@ export default function Home() {
 `
     );
   } else if (template === "sveltekit") {
-    const pagePath = path2.join(projectPath, "src", "routes", "+page.svelte");
-    await fs2.writeFile(
+    const pagePath = path3.join(projectPath, "src", "routes", "+page.svelte");
+    await fs3.writeFile(
       pagePath,
       `<script lang="ts">
   import { onMount } from 'svelte';
@@ -1038,109 +1319,69 @@ export default function Home() {
     );
   }
 }
-async function runInitialMigration(projectPath, projectId, apiKey) {
-  const migrationSql = `
-    CREATE TABLE IF NOT EXISTS posts (
-      id TEXT PRIMARY KEY,
-      title TEXT NOT NULL,
-      content TEXT,
-      authorId TEXT NOT NULL,
-      createdAt TEXT NOT NULL DEFAULT (datetime('now')),
-      updatedAt TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-
-    CREATE TABLE IF NOT EXISTS comments (
-      id TEXT PRIMARY KEY,
-      postId TEXT NOT NULL REFERENCES posts(id),
-      content TEXT NOT NULL,
-      authorId TEXT NOT NULL,
-      createdAt TEXT NOT NULL DEFAULT (datetime('now'))
-    );
-
-    CREATE INDEX IF NOT EXISTS idx_posts_authorId ON posts(authorId);
-    CREATE INDEX IF NOT EXISTS idx_posts_createdAt ON posts(createdAt);
-    CREATE INDEX IF NOT EXISTS idx_comments_postId ON comments(postId);
-  `;
-  try {
-    const response = await fetch(`${API_URL}/${projectId}/mutation`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${apiKey}`
-      },
-      body: JSON.stringify({
-        function: "_migrate",
-        args: { sql: migrationSql }
-      })
-    });
-    if (!response.ok) {
-    }
-  } catch {
-  }
-}
 
 // src/commands/dev.ts
-import chalk3 from "chalk";
-import ora2 from "ora";
-import fs3 from "fs-extra";
-import path3 from "path";
+import chalk4 from "chalk";
+import ora3 from "ora";
+import fs4 from "fs-extra";
+import path4 from "path";
 async function devCommand(options) {
   await requireAuth();
-  const configPath = path3.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs3.pathExists(configPath)) {
-    console.log(chalk3.red("\nError: Not a Tether project"));
-    console.log(chalk3.dim("Run `tthr init` to create a new project\n"));
+  const configPath = path4.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs4.pathExists(configPath)) {
+    console.log(chalk4.red("\nError: Not a Tether project"));
+    console.log(chalk4.dim("Run `tthr init` to create a new project\n"));
     process.exit(1);
   }
-  console.log(chalk3.bold("\n\u26A1 Starting Tether development server\n"));
-  const spinner = ora2("Starting server...").start();
+  console.log(chalk4.bold("\n\u26A1 Starting Tether development server\n"));
+  const spinner = ora3("Starting server...").start();
   try {
     spinner.succeed(`Development server running on port ${options.port}`);
-    console.log("\n" + chalk3.cyan(`  Local:   http://localhost:${options.port}`));
-    console.log(chalk3.cyan(`  WebSocket: ws://localhost:${options.port}/ws
+    console.log("\n" + chalk4.cyan(`  Local:   http://localhost:${options.port}`));
+    console.log(chalk4.cyan(`  WebSocket: ws://localhost:${options.port}/ws
 `));
-    console.log(chalk3.dim("  Press Ctrl+C to stop\n"));
+    console.log(chalk4.dim("  Press Ctrl+C to stop\n"));
     process.on("SIGINT", () => {
-      console.log(chalk3.yellow("\n\nShutting down...\n"));
+      console.log(chalk4.yellow("\n\nShutting down...\n"));
       process.exit(0);
     });
     await new Promise(() => {
     });
   } catch (error) {
     spinner.fail("Failed to start server");
-    console.error(chalk3.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk4.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 
 // src/commands/generate.ts
-import chalk4 from "chalk";
-import ora3 from "ora";
-import fs4 from "fs-extra";
-import path4 from "path";
+import chalk5 from "chalk";
+import ora4 from "ora";
+import fs5 from "fs-extra";
+import path5 from "path";
 async function generateCommand() {
   await requireAuth();
-  const configPath = path4.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs4.pathExists(configPath)) {
-    console.log(chalk4.red("\nError: Not a Tether project"));
-    console.log(chalk4.dim("Run `tthr init` to create a new project\n"));
+  const configPath = path5.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs5.pathExists(configPath)) {
+    console.log(chalk5.red("\nError: Not a Tether project"));
+    console.log(chalk5.dim("Run `tthr init` to create a new project\n"));
     process.exit(1);
   }
-  console.log(chalk4.bold("\n\u26A1 Generating types from schema\n"));
-  const spinner = ora3("Reading schema...").start();
+  console.log(chalk5.bold("\n\u26A1 Generating types from schema\n"));
+  const spinner = ora4("Reading schema...").start();
   try {
-    const schemaPath = path4.resolve(process.cwd(), "tether", "schema.ts");
-    const outputDir = path4.resolve(process.cwd(), "_generated");
-    if (!await fs4.pathExists(schemaPath)) {
+    const schemaPath = path5.resolve(process.cwd(), "tether", "schema.ts");
+    const outputDir = path5.resolve(process.cwd(), "_generated");
+    if (!await fs5.pathExists(schemaPath)) {
       spinner.fail("Schema file not found");
-      console.log(chalk4.dim(`Expected: ${schemaPath}
+      console.log(chalk5.dim(`Expected: ${schemaPath}
 `));
       process.exit(1);
     }
     spinner.text = "Generating types...";
-    await fs4.ensureDir(outputDir);
-    await fs4.writeFile(
-      path4.join(outputDir, "db.ts"),
+    await fs5.ensureDir(outputDir);
+    await fs5.writeFile(
+      path5.join(outputDir, "db.ts"),
       `// Auto-generated by Tether CLI - do not edit manually
 // Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
 
@@ -1172,8 +1413,8 @@ export interface Schema {
 export declare const db: TetherDatabase<Schema>;
 `
     );
-    await fs4.writeFile(
-      path4.join(outputDir, "api.ts"),
+    await fs5.writeFile(
+      path5.join(outputDir, "api.ts"),
       `// Auto-generated by Tether CLI - do not edit manually
 // Generated at: ${(/* @__PURE__ */ new Date()).toISOString()}
 
@@ -1196,40 +1437,40 @@ export interface Api {
 export declare const tether: TetherClient<Api>;
 `
     );
-    await fs4.writeFile(
-      path4.join(outputDir, "index.ts"),
+    await fs5.writeFile(
+      path5.join(outputDir, "index.ts"),
       `// Auto-generated by Tether CLI - do not edit manually
 export * from './db';
 export * from './api';
 `
     );
     spinner.succeed("Types generated");
-    console.log("\n" + chalk4.green("\u2713") + " Generated files:");
-    console.log(chalk4.dim("  _generated/db.ts"));
-    console.log(chalk4.dim("  _generated/api.ts"));
-    console.log(chalk4.dim("  _generated/index.ts\n"));
+    console.log("\n" + chalk5.green("\u2713") + " Generated files:");
+    console.log(chalk5.dim("  _generated/db.ts"));
+    console.log(chalk5.dim("  _generated/api.ts"));
+    console.log(chalk5.dim("  _generated/index.ts\n"));
   } catch (error) {
     spinner.fail("Failed to generate types");
-    console.error(chalk4.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 
 // src/commands/migrate.ts
-import chalk5 from "chalk";
-import ora4 from "ora";
-import fs5 from "fs-extra";
-import path5 from "path";
+import chalk6 from "chalk";
+import ora5 from "ora";
+import fs6 from "fs-extra";
+import path6 from "path";
 import prompts2 from "prompts";
 async function migrateCommand(action, options) {
   await requireAuth();
-  const configPath = path5.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs5.pathExists(configPath)) {
-    console.log(chalk5.red("\nError: Not a Tether project"));
-    console.log(chalk5.dim("Run `tthr init` to create a new project\n"));
+  const configPath = path6.resolve(process.cwd(), "tether.config.ts");
+  if (!await fs6.pathExists(configPath)) {
+    console.log(chalk6.red("\nError: Not a Tether project"));
+    console.log(chalk6.dim("Run `tthr init` to create a new project\n"));
     process.exit(1);
   }
-  const migrationsDir = path5.resolve(process.cwd(), "tether", "migrations");
+  const migrationsDir = path6.resolve(process.cwd(), "tether", "migrations");
   switch (action) {
     case "create":
       await createMigration(migrationsDir, options.name);
@@ -1247,7 +1488,7 @@ async function migrateCommand(action, options) {
   }
 }
 async function createMigration(migrationsDir, name) {
-  console.log(chalk5.bold("\n\u26A1 Create migration\n"));
+  console.log(chalk6.bold("\n\u26A1 Create migration\n"));
   let migrationName = name;
   if (!migrationName) {
     const response = await prompts2({
@@ -1258,17 +1499,17 @@ async function createMigration(migrationsDir, name) {
     });
     migrationName = response.name;
     if (!migrationName) {
-      console.log(chalk5.red("Migration name is required"));
+      console.log(chalk6.red("Migration name is required"));
       process.exit(1);
     }
   }
-  const spinner = ora4("Creating migration...").start();
+  const spinner = ora5("Creating migration...").start();
   try {
-    await fs5.ensureDir(migrationsDir);
+    await fs6.ensureDir(migrationsDir);
     const timestamp = Date.now();
     const filename = `${timestamp}_${migrationName}.sql`;
-    const filepath = path5.join(migrationsDir, filename);
-    await fs5.writeFile(
+    const filepath = path6.join(migrationsDir, filename);
+    await fs6.writeFile(
       filepath,
       `-- Migration: ${migrationName}
 -- Created at: ${(/* @__PURE__ */ new Date()).toISOString()}
@@ -1289,335 +1530,72 @@ async function createMigration(migrationsDir, name) {
 `
     );
     spinner.succeed("Migration created");
-    console.log(chalk5.dim(`
+    console.log(chalk6.dim(`
   ${filepath}
 `));
   } catch (error) {
     spinner.fail("Failed to create migration");
-    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 async function runMigrations(migrationsDir, direction) {
-  console.log(chalk5.bold(`
+  console.log(chalk6.bold(`
 \u26A1 Running migrations (${direction})
 `));
-  const spinner = ora4("Checking migrations...").start();
+  const spinner = ora5("Checking migrations...").start();
   try {
-    if (!await fs5.pathExists(migrationsDir)) {
+    if (!await fs6.pathExists(migrationsDir)) {
       spinner.info("No migrations directory found");
-      console.log(chalk5.dim("\nRun `tthr migrate create` to create your first migration\n"));
+      console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
       return;
     }
-    const files = await fs5.readdir(migrationsDir);
+    const files = await fs6.readdir(migrationsDir);
     const migrations = files.filter((f) => f.endsWith(".sql")).sort((a, b) => direction === "up" ? a.localeCompare(b) : b.localeCompare(a));
     if (migrations.length === 0) {
       spinner.info("No migrations found");
-      console.log(chalk5.dim("\nRun `tthr migrate create` to create your first migration\n"));
+      console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
       return;
     }
     spinner.text = `Found ${migrations.length} migration(s)`;
     spinner.succeed(`Would run ${migrations.length} migration(s)`);
     console.log("\nMigrations to run:");
     for (const migration of migrations) {
-      console.log(chalk5.dim(`  ${migration}`));
+      console.log(chalk6.dim(`  ${migration}`));
     }
-    console.log(chalk5.yellow("\nNote: Migration execution not yet implemented\n"));
+    console.log(chalk6.yellow("\nNote: Migration execution not yet implemented\n"));
   } catch (error) {
     spinner.fail("Failed to run migrations");
-    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
+    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
     process.exit(1);
   }
 }
 async function showStatus(migrationsDir) {
-  console.log(chalk5.bold("\n\u26A1 Migration status\n"));
+  console.log(chalk6.bold("\n\u26A1 Migration status\n"));
   try {
-    if (!await fs5.pathExists(migrationsDir)) {
-      console.log(chalk5.dim("No migrations directory found"));
-      console.log(chalk5.dim("\nRun `tthr migrate create` to create your first migration\n"));
+    if (!await fs6.pathExists(migrationsDir)) {
+      console.log(chalk6.dim("No migrations directory found"));
+      console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
       return;
     }
-    const files = await fs5.readdir(migrationsDir);
+    const files = await fs6.readdir(migrationsDir);
     const migrations = files.filter((f) => f.endsWith(".sql")).sort();
     if (migrations.length === 0) {
-      console.log(chalk5.dim("No migrations found"));
-      console.log(chalk5.dim("\nRun `tthr migrate create` to create your first migration\n"));
+      console.log(chalk6.dim("No migrations found"));
+      console.log(chalk6.dim("\nRun `tthr migrate create` to create your first migration\n"));
       return;
     }
     console.log(`Found ${migrations.length} migration(s):
 `);
     for (const migration of migrations) {
-      console.log(chalk5.yellow("  \u25CB") + ` ${migration} ${chalk5.dim("(pending)")}`);
+      console.log(chalk6.yellow("  \u25CB") + ` ${migration} ${chalk6.dim("(pending)")}`);
     }
     console.log();
   } catch (error) {
-    console.error(chalk5.red(error instanceof Error ? error.message : "Unknown error"));
-    process.exit(1);
-  }
-}
-
-// src/commands/deploy.ts
-import chalk6 from "chalk";
-import ora5 from "ora";
-import fs6 from "fs-extra";
-import path6 from "path";
-var isDev2 = process.env.NODE_ENV === "development" || process.env.TETHER_DEV === "true";
-var API_URL2 = isDev2 ? "http://localhost:3001/api/v1" : "https://tthr.io/api/v1";
-async function deployCommand(options) {
-  const credentials = await requireAuth();
-  const configPath = path6.resolve(process.cwd(), "tether.config.ts");
-  if (!await fs6.pathExists(configPath)) {
-    console.log(chalk6.red("\nError: Not a Tether project"));
-    console.log(chalk6.dim("Run `tthr init` to create a new project\n"));
-    process.exit(1);
-  }
-  const envPath = path6.resolve(process.cwd(), ".env");
-  let projectId;
-  if (await fs6.pathExists(envPath)) {
-    const envContent = await fs6.readFile(envPath, "utf-8");
-    const match = envContent.match(/TETHER_PROJECT_ID=(.+)/);
-    projectId = match?.[1]?.trim();
-  }
-  if (!projectId) {
-    console.log(chalk6.red("\nError: Project ID not found"));
-    console.log(chalk6.dim("Make sure TETHER_PROJECT_ID is set in your .env file\n"));
-    process.exit(1);
-  }
-  console.log(chalk6.bold("\n\u26A1 Deploying to Tether\n"));
-  console.log(chalk6.dim(`  Project: ${projectId}`));
-  console.log(chalk6.dim(`  API: ${API_URL2}
-`));
-  const deploySchema = options.schema || !options.schema && !options.functions;
-  const deployFunctions = options.functions || !options.schema && !options.functions;
-  if (deploySchema) {
-    await deploySchemaToServer(projectId, credentials.accessToken, options.dryRun);
-  }
-  if (deployFunctions) {
-    await deployFunctionsToServer(projectId, credentials.accessToken, options.dryRun);
-  }
-  console.log(chalk6.green("\n\u2713 Deployment complete\n"));
-}
-async function deploySchemaToServer(projectId, token, dryRun) {
-  const spinner = ora5("Reading schema...").start();
-  try {
-    const schemaPath = path6.resolve(process.cwd(), "tether", "schema.ts");
-    if (!await fs6.pathExists(schemaPath)) {
-      spinner.warn("No schema file found");
-      console.log(chalk6.dim("  Create tether/schema.ts to define your database schema\n"));
-      return;
-    }
-    const schemaSource = await fs6.readFile(schemaPath, "utf-8");
-    const tables = parseSchema(schemaSource);
-    spinner.text = `Found ${tables.length} table(s)`;
-    if (dryRun) {
-      spinner.info("Dry run - would deploy schema:");
-      for (const table of tables) {
-        console.log(chalk6.dim(`  - ${table.name}`));
-      }
-      return;
-    }
-    const sql = generateSchemaSQL(tables);
-    spinner.text = "Deploying schema...";
-    const response = await fetch(`${API_URL2}/${projectId}/mutation`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${token}`
-      },
-      body: JSON.stringify({
-        function: "_migrate",
-        args: { sql }
-      })
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: "Unknown error" }));
-      throw new Error(error.error || `HTTP ${response.status}`);
-    }
-    spinner.succeed(`Schema deployed (${tables.length} table(s))`);
-  } catch (error) {
-    spinner.fail("Failed to deploy schema");
     console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
+    process.exit(1);
   }
 }
-async function deployFunctionsToServer(projectId, token, dryRun) {
-  const spinner = ora5("Reading functions...").start();
-  try {
-    const functionsDir = path6.resolve(process.cwd(), "tether", "functions");
-    if (!await fs6.pathExists(functionsDir)) {
-      spinner.warn("No functions directory found");
-      console.log(chalk6.dim("  Create tether/functions/ to define your API functions\n"));
-      return;
-    }
-    const files = await fs6.readdir(functionsDir);
-    const tsFiles = files.filter((f) => f.endsWith(".ts"));
-    if (tsFiles.length === 0) {
-      spinner.info("No function files found");
-      return;
-    }
-    const functions = [];
-    for (const file of tsFiles) {
-      const filePath = path6.join(functionsDir, file);
-      const source = await fs6.readFile(filePath, "utf-8");
-      const moduleName = file.replace(".ts", "");
-      const parsedFunctions = parseFunctions(moduleName, source);
-      functions.push(...parsedFunctions);
-    }
-    spinner.text = `Found ${functions.length} function(s)`;
-    if (dryRun) {
-      spinner.info("Dry run - would deploy functions:");
-      for (const fn of functions) {
-        const icon = fn.type === "query" ? "\u{1F50D}" : fn.type === "mutation" ? "\u270F\uFE0F" : "\u26A1";
-        console.log(chalk6.dim(`  ${icon} ${fn.name} (${fn.type})`));
-      }
-      return;
-    }
-    spinner.text = "Deploying functions...";
-    const response = await fetch(`${API_URL2}/${projectId}/deploy/functions`, {
-      method: "POST",
-      headers: {
-        "Content-Type": "application/json",
-        "Authorization": `Bearer ${token}`
-      },
-      body: JSON.stringify({
-        functions: functions.map((fn) => ({
-          name: fn.name,
-          type: fn.type,
-          source: fn.source
-        }))
-      })
-    });
-    if (!response.ok) {
-      const error = await response.json().catch(() => ({ error: "Unknown error" }));
-      throw new Error(error.error || `HTTP ${response.status}`);
-    }
-    spinner.succeed(`Functions deployed (${functions.length} function(s))`);
-    const queries = functions.filter((f) => f.type === "query");
-    const mutations = functions.filter((f) => f.type === "mutation");
-    const actions = functions.filter((f) => f.type === "action");
-    if (queries.length > 0) {
-      console.log(chalk6.dim(`
-  Queries:`));
-      for (const fn of queries) {
-        console.log(chalk6.dim(`    - ${fn.name}`));
-      }
-    }
-    if (mutations.length > 0) {
-      console.log(chalk6.dim(`
-  Mutations:`));
-      for (const fn of mutations) {
-        console.log(chalk6.dim(`    - ${fn.name}`));
-      }
-    }
-    if (actions.length > 0) {
-      console.log(chalk6.dim(`
-  Actions:`));
-      for (const fn of actions) {
-        console.log(chalk6.dim(`    - ${fn.name}`));
-      }
-    }
-  } catch (error) {
-    spinner.fail("Failed to deploy functions");
-    console.error(chalk6.red(error instanceof Error ? error.message : "Unknown error"));
-  }
-}
-function parseSchema(source) {
-  const tables = [];
-  const schemaMatch = source.match(/defineSchema\s*\(\s*\{([\s\S]*)\}\s*\)/);
-  if (!schemaMatch) return tables;
-  const schemaContent = schemaMatch[1];
-  const tableRegex = /(\w+)\s*:\s*\{([^}]+(?:\{[^}]*\}[^}]*)*)\}/g;
-  let match;
-  while ((match = tableRegex.exec(schemaContent)) !== null) {
-    const tableName = match[1];
-    const columnsContent = match[2];
-    const columns = {};
-    const columnRegex = /(\w+)\s*:\s*(\w+)\s*\(\s*\)([^,\n]*)/g;
-    let colMatch;
-    while ((colMatch = columnRegex.exec(columnsContent)) !== null) {
-      const colName = colMatch[1];
-      const colType = colMatch[2];
-      const modifiers = colMatch[3];
-      columns[colName] = {
-        type: colType,
-        primaryKey: modifiers.includes(".primaryKey()"),
-        notNull: modifiers.includes(".notNull()"),
-        unique: modifiers.includes(".unique()"),
-        hasDefault: modifiers.includes(".default("),
-        references: modifiers.match(/\.references\s*\(\s*['"]([^'"]+)['"]\s*\)/)?.[1]
-      };
-    }
-    tables.push({ name: tableName, columns });
-  }
-  return tables;
-}
-function generateSchemaSQL(tables) {
-  const statements = [];
-  for (const table of tables) {
-    const columnDefs = [];
-    for (const [colName, colDef] of Object.entries(table.columns)) {
-      const def = colDef;
-      let sqlType = "TEXT";
-      switch (def.type) {
-        case "text":
-          sqlType = "TEXT";
-          break;
-        case "integer":
-          sqlType = "INTEGER";
-          break;
-        case "real":
-          sqlType = "REAL";
-          break;
-        case "blob":
-          sqlType = "BLOB";
-          break;
-        case "timestamp":
-          sqlType = "TEXT";
-          break;
-        case "boolean":
-          sqlType = "INTEGER";
-          break;
-        case "json":
-          sqlType = "TEXT";
-          break;
-      }
-      let colSql = `${colName} ${sqlType}`;
-      if (def.primaryKey) colSql += " PRIMARY KEY";
-      if (def.notNull) colSql += " NOT NULL";
-      if (def.unique) colSql += " UNIQUE";
-      if (def.hasDefault && def.type === "timestamp") {
-        colSql += " DEFAULT (datetime('now'))";
-      }
-      if (def.references) {
-        const [refTable, refCol] = def.references.split(".");
-        colSql += ` REFERENCES ${refTable}(${refCol})`;
-      }
-      columnDefs.push(colSql);
-    }
-    statements.push(
-      `CREATE TABLE IF NOT EXISTS ${table.name} (
-  ${columnDefs.join(",\n  ")}
-);`
-    );
-  }
-  return statements.join("\n\n");
-}
-function parseFunctions(moduleName, source) {
-  const functions = [];
-  const fnRegex = /export\s+const\s+(\w+)\s*=\s*(query|mutation|action)\s*\(\s*\{([\s\S]*?)\}\s*\)/g;
-  let match;
-  while ((match = fnRegex.exec(source)) !== null) {
-    const fnName = match[1];
-    const fnType = match[2];
-    const fnBody = match[3];
-    functions.push({
-      name: `${moduleName}.${fnName}`,
-      type: fnType,
-      file: `${moduleName}.ts`,
-      source: `${fnType}({${fnBody}})`
-    });
-  }
-  return functions;
-}
 
 // src/commands/login.ts
 import chalk7 from "chalk";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tthr/cli",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Tether CLI - project scaffolding, migrations, and deployment",
   "type": "module",
   "bin": {