@beaulewis/saas-cli 1.0.0

package/dist/index.js

@@ -0,0 +1,1437 @@
+import {
+  cacheKey,
+  cachedFetch,
+  createAuthenticatedClient,
+  formatTable,
+  getAPIKey,
+  loadGlobalConfig
+} from "./chunk-3KD5CFV3.js";
+import {
+  columnsToSQL,
+  parseColumnSpec
+} from "./chunk-ZD2ZSBK3.js";
+import {
+  AuthError,
+  CLIError,
+  MODEL_ALIASES,
+  handleError
+} from "./chunk-5BCEXHNM.js";
+
+// src/cli.ts
+import { Command as Command11 } from "commander";
+import pc8 from "picocolors";
+
+// src/commands/ask/index.ts
+import { Command } from "commander";
+import ora from "ora";
+import pc from "picocolors";
+
+// src/services/perplexity.ts
+var PERPLEXITY_BASE_URL = "https://api.perplexity.ai";
+var PerplexityClient = class {
+  client;
+  constructor(apiKey) {
+    this.client = createAuthenticatedClient(PERPLEXITY_BASE_URL, apiKey);
+  }
+  /**
+   * Ask a question using Perplexity AI
+   */
+  async ask(query, options = {}) {
+    const model = options.model ?? "sonar";
+    const requestBody = {
+      model,
+      messages: [
+        {
+          role: "system",
+          content: "You are a helpful assistant for software development questions. Be precise and include code examples when relevant. Focus on Flutter, Dart, and related technologies."
+        },
+        {
+          role: "user",
+          content: query
+        }
+      ],
+      max_tokens: options.maxTokens ?? 2048,
+      temperature: options.temperature ?? 0.2,
+      return_related_questions: false
+    };
+    if (options.searchRecencyFilter) {
+      requestBody.search_recency_filter = options.searchRecencyFilter;
+    }
+    if (options.searchDomainFilter && options.searchDomainFilter.length > 0) {
+      requestBody.search_domain_filter = options.searchDomainFilter;
+    }
+    const response = await this.client.post("chat/completions", {
+      json: requestBody
+    }).json();
+    return this.formatResponse(response, options.returnSources);
+  }
+  /**
+   * Ask with caching enabled
+   */
+  async askCached(query, options = {}) {
+    const model = options.model ?? "sonar";
+    const key = cacheKey("perplexity", model, query);
+    return cachedFetch(
+      key,
+      () => this.ask(query, options),
+      1800 * 1e3
+      // 30 minute cache for AI responses
+    );
+  }
+  /**
+   * Format the API response
+   */
+  formatResponse(response, includeSources) {
+    const choice = response.choices[0];
+    if (!choice) {
+      return "No response received from AI.";
+    }
+    let output = choice.message.content;
+    if (includeSources && response.citations && response.citations.length > 0) {
+      output += "\n\n---\nSources:\n";
+      response.citations.forEach((url, i) => {
+        output += `[${i + 1}] ${url}
+`;
+      });
+    }
+    return output;
+  }
+};
+var clientInstance = null;
+var currentApiKey = null;
+function getPerplexityClient(apiKey) {
+  if (!clientInstance || currentApiKey !== apiKey) {
+    clientInstance = new PerplexityClient(apiKey);
+    currentApiKey = apiKey;
+  }
+  return clientInstance;
+}
+
+// src/commands/ask/index.ts
+var askCommand = new Command("ask").description("Ask AI-powered questions with web search (Perplexity)").argument("<query>", "Your question").option("-m, --model <model>", "Model: sonar, pro, reasoning, deep", "sonar").option("--recent <period>", "Filter by recency: day, week, month, year").option("--domains <domains>", "Limit to domains (comma-separated)").option("--sources", "Include source URLs in output").option("--json", "Output as JSON").action(async (query, options) => {
+  const modelAlias = options.model ?? "sonar";
+  const model = MODEL_ALIASES[modelAlias] ?? "sonar";
+  const modelDisplay = modelAlias.toUpperCase();
+  const spinner = ora(`Asking ${modelDisplay}...`).start();
+  try {
+    const config = await loadGlobalConfig();
+    const apiKey = getAPIKey("perplexity", config);
+    if (!apiKey) {
+      spinner.fail("Perplexity API key not found");
+      throw new AuthError(
+        "PERPLEXITY_API_KEY environment variable is not set",
+        "Get your API key from https://perplexity.ai/settings/api and set PERPLEXITY_API_KEY"
+      );
+    }
+    const client = getPerplexityClient(apiKey);
+    const result = await client.ask(query, {
+      model,
+      searchRecencyFilter: options.recent,
+      searchDomainFilter: options.domains?.split(","),
+      returnSources: options.sources
+    });
+    spinner.stop();
+    if (options.json) {
+      console.log(JSON.stringify({ query, model: modelAlias, result }, null, 2));
+    } else {
+      console.log(pc.cyan(`
+\u2501\u2501\u2501 ${modelDisplay} \u2501\u2501\u2501
+`));
+      console.log(result);
+    }
+  } catch (error) {
+    spinner.fail("Query failed");
+    handleError(error);
+  }
+});
+
+// src/commands/cf/index.ts
+import { exec } from "child_process";
+import { promisify } from "util";
+import { Command as Command2 } from "commander";
+import ora2 from "ora";
+var execAsync = promisify(exec);
+async function checkWranglerCLI() {
+  try {
+    await execAsync("wrangler --version");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runWranglerCommand(args) {
+  const isInstalled = await checkWranglerCLI();
+  if (!isInstalled) {
+    throw new CLIError("Wrangler CLI not found", 1, "Install with: pnpm add -g wrangler");
+  }
+  if (!process.env.CF_API_TOKEN && !process.env.CLOUDFLARE_API_TOKEN) {
+    throw new AuthError(
+      "Cloudflare API token not found",
+      "Set CF_API_TOKEN or CLOUDFLARE_API_TOKEN environment variable"
+    );
+  }
+  try {
+    const { stdout, stderr } = await execAsync(`wrangler ${args.join(" ")}`);
+    if (stderr && !stderr.includes("warning")) {
+      console.error(stderr);
+    }
+    return stdout;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CLIError(`Wrangler command failed: ${message}`);
+  }
+}
+var cfCommand = new Command2("cf").description("Cloudflare Workers and KV management").addCommand(
+  new Command2("worker").description("Worker management").argument("<action>", "Action: new, deploy, logs, list").argument("[name]", "Worker name").action(async (action, name) => {
+    const spinner = ora2(`Worker ${action}...`).start();
+    try {
+      let args;
+      switch (action) {
+        case "new":
+          if (!name) throw new CLIError('Worker name required for "new" action');
+          args = ["init", name];
+          break;
+        case "deploy":
+          args = name ? ["deploy", "--name", name] : ["deploy"];
+          break;
+        case "logs":
+          args = name ? ["tail", name] : ["tail"];
+          break;
+        case "list":
+          args = ["deployments", "list"];
+          break;
+        default:
+          throw new CLIError(
+            `Invalid action: "${action}"`,
+            1,
+            "Valid actions: new, deploy, logs, list"
+          );
+      }
+      const output = await runWranglerCommand(args);
+      spinner.stop();
+      console.log(output);
+    } catch (error) {
+      spinner.fail(`Worker ${action} failed`);
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command2("kv").description("KV namespace operations").argument("<action>", "Action: namespaces, keys, get, put, del").argument("[namespace]", "KV namespace ID").argument("[key]", "Key name").argument("[value]", "Value (for put)").action(async (action, namespace, key, value) => {
+    const spinner = ora2(`KV ${action}...`).start();
+    try {
+      let args;
+      switch (action) {
+        case "namespaces":
+          args = ["kv:namespace", "list"];
+          break;
+        case "keys":
+          if (!namespace) throw new CLIError("Namespace ID required");
+          args = ["kv:key", "list", "--namespace-id", namespace];
+          break;
+        case "get":
+          if (!namespace || !key) throw new CLIError("Namespace and key required");
+          args = ["kv:key", "get", key, "--namespace-id", namespace];
+          break;
+        case "put":
+          if (!namespace || !key || !value)
+            throw new CLIError("Namespace, key, and value required");
+          args = ["kv:key", "put", key, value, "--namespace-id", namespace];
+          break;
+        case "del":
+          if (!namespace || !key) throw new CLIError("Namespace and key required");
+          args = ["kv:key", "delete", key, "--namespace-id", namespace];
+          break;
+        default:
+          throw new CLIError(
+            `Invalid action: "${action}"`,
+            1,
+            "Valid actions: namespaces, keys, get, put, del"
+          );
+      }
+      const output = await runWranglerCommand(args);
+      spinner.stop();
+      console.log(output);
+    } catch (error) {
+      spinner.fail(`KV ${action} failed`);
+      handleError(error);
+    }
+  })
+);
+
+// src/commands/docs/index.ts
+import { Command as Command3 } from "commander";
+var docsCommand = new Command3("docs").description("Look up documentation via Context7").addCommand(
+  new Command3("flutter").description("Search Flutter documentation").argument("<query>", "Search query").action(async (query) => {
+    const { flutterAction } = await import("./flutter-J5BYPVIW.js");
+    await flutterAction(query);
+  })
+).addCommand(
+  new Command3("dart").description("Search Dart documentation").argument("<query>", "Search query").action(async (query) => {
+    const { dartAction } = await import("./dart-DXLFNGHR.js");
+    await dartAction(query);
+  })
+).addCommand(
+  new Command3("package").description("Search package documentation").argument("<package>", "Package name").argument("[query]", "Search query").action(async (pkg, query) => {
+    const { packageAction } = await import("./package-QO75XHBD.js");
+    await packageAction(pkg, query);
+  })
+).addCommand(
+  new Command3("widget").description("Look up widget documentation").argument("<name>", "Widget name").option("--properties", "Show all properties").action(async (name, options) => {
+    const { widgetAction } = await import("./widget-YDKHPRXM.js");
+    await widgetAction(name, options);
+  })
+);
+
+// src/commands/flags/index.ts
+import { Command as Command4 } from "commander";
+import got from "got";
+import ora3 from "ora";
+import pc2 from "picocolors";
+var POSTHOG_API = "https://app.posthog.com/api";
+async function getPostHogConfig() {
+  const projectId = process.env.POSTHOG_PROJECT_ID;
+  const apiKey = process.env.POSTHOG_API_KEY;
+  if (!projectId || !apiKey) {
+    const config = await loadGlobalConfig();
+    return {
+      projectId: projectId || config.posthog?.projectId,
+      apiKey: apiKey || config.posthog?.apiKey
+    };
+  }
+  return { projectId, apiKey };
+}
+var flagsCommand = new Command4("flags").description("PostHog feature flag management").addCommand(
+  new Command4("list").description("List all feature flags").action(async () => {
+    const spinner = ora3("Fetching feature flags...").start();
+    try {
+      const { projectId, apiKey } = await getPostHogConfig();
+      if (!projectId || !apiKey) {
+        throw new AuthError(
+          "PostHog credentials not found",
+          "Set POSTHOG_PROJECT_ID and POSTHOG_API_KEY environment variables"
+        );
+      }
+      const response = await got.get(`${POSTHOG_API}/projects/${projectId}/feature_flags`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      }).json();
+      spinner.stop();
+      const rows = response.results.map((flag) => [
+        flag.key,
+        flag.active ? pc2.green("enabled") : pc2.red("disabled"),
+        flag.rollout_percentage !== void 0 ? `${flag.rollout_percentage}%` : "100%"
+      ]);
+      console.log(formatTable(["Flag", "Status", "Rollout"], rows));
+    } catch (error) {
+      spinner.fail("Failed to fetch feature flags");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command4("get").description("Get feature flag details").argument("<flag>", "Flag key").action(async (flag) => {
+    const spinner = ora3(`Fetching flag: ${flag}...`).start();
+    try {
+      const { projectId, apiKey } = await getPostHogConfig();
+      if (!projectId || !apiKey) {
+        throw new AuthError(
+          "PostHog credentials not found",
+          "Set POSTHOG_PROJECT_ID and POSTHOG_API_KEY environment variables"
+        );
+      }
+      const response = await got.get(`${POSTHOG_API}/projects/${projectId}/feature_flags`, {
+        headers: { Authorization: `Bearer ${apiKey}` },
+        searchParams: { key: flag }
+      }).json();
+      spinner.stop();
+      const flagData = response.results.find((f) => f.key === flag);
+      if (!flagData) {
+        console.log(pc2.yellow(`Flag "${flag}" not found`));
+        return;
+      }
+      console.log(pc2.cyan(`Flag: ${flagData.key}`));
+      console.log(`  Name: ${flagData.name || "N/A"}`);
+      console.log(`  Status: ${flagData.active ? pc2.green("enabled") : pc2.red("disabled")}`);
+      console.log(`  Rollout: ${flagData.rollout_percentage ?? 100}%`);
+    } catch (error) {
+      spinner.fail("Failed to fetch flag");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command4("set").description("Enable or disable a feature flag").argument("<flag>", "Flag key").argument("<value>", "true/false or percentage (0-100)").action(async (flag, value) => {
+    const spinner = ora3(`Updating flag: ${flag}...`).start();
+    try {
+      const { projectId, apiKey } = await getPostHogConfig();
+      if (!projectId || !apiKey) {
+        throw new AuthError(
+          "PostHog credentials not found",
+          "Set POSTHOG_PROJECT_ID and POSTHOG_API_KEY environment variables"
+        );
+      }
+      const listResponse = await got.get(`${POSTHOG_API}/projects/${projectId}/feature_flags`, {
+        headers: { Authorization: `Bearer ${apiKey}` }
+      }).json();
+      const flagData = listResponse.results.find((f) => f.key === flag);
+      if (!flagData) {
+        spinner.fail(`Flag "${flag}" not found`);
+        return;
+      }
+      const isPercentage = /^\d+$/.test(value) && Number.parseInt(value, 10) <= 100;
+      const isBoolean = value === "true" || value === "false";
+      const updateData = {};
+      if (isPercentage) {
+        updateData.rollout_percentage = Number.parseInt(value, 10);
+      } else if (isBoolean) {
+        updateData.active = value === "true";
+      } else {
+        spinner.fail("Value must be true, false, or a percentage (0-100)");
+        return;
+      }
+      await got.patch(`${POSTHOG_API}/projects/${projectId}/feature_flags/${flagData.id}`, {
+        headers: {
+          Authorization: `Bearer ${apiKey}`,
+          "Content-Type": "application/json"
+        },
+        json: updateData
+      });
+      spinner.succeed("Feature flag updated");
+      console.log(pc2.green(`${flag} = ${value}`));
+    } catch (error) {
+      spinner.fail("Failed to update flag");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command4("add-user").description("Add user to flag override").argument("<flag>", "Flag key").argument("<userId>", "User ID").action(async (flag, userId) => {
+    console.log(pc2.yellow("Note: User-level overrides require PostHog Enterprise"));
+    console.log(pc2.dim(`Would add user ${userId} to flag ${flag}`));
+  })
+).addCommand(
+  new Command4("remove-user").description("Remove user from flag override").argument("<flag>", "Flag key").argument("<userId>", "User ID").action(async (flag, userId) => {
+    console.log(pc2.yellow("Note: User-level overrides require PostHog Enterprise"));
+    console.log(pc2.dim(`Would remove user ${userId} from flag ${flag}`));
+  })
+);
+
+// src/commands/gen/index.ts
+import { Command as Command5 } from "commander";
+var genCommand = new Command5("gen").description("Generate boilerplate code for Flutter/Dart patterns").addCommand(
+  new Command5("riverpod").description("Generate Riverpod providers").argument("<pattern>", "Pattern: notifier, async-notifier, future, stream, family").argument("<name>", "Provider name").option("-s, --state <type>", 'State type (e.g., "List<User>")').option("-o, --output <path>", "Output file path").action(async (pattern, name, options) => {
+    const { riverpodAction } = await import("./riverpod-XUU656PM.js");
+    await riverpodAction(pattern, name, options);
+  })
+).addCommand(
+  new Command5("drift").description("Generate Drift database code").argument("<type>", "Type: table, dao, migration").argument("<name>", "Table or DAO name").option("-c, --columns <spec>", "Column specification (for table)").option("-o, --output <path>", "Output file path").action(async (type, name, options) => {
+    const { driftAction } = await import("./drift-XYY4D366.js");
+    await driftAction(type, name, options);
+  })
+).addCommand(
+  new Command5("gorouter").description("Generate GoRouter routes").argument("<name>", "Route name").option("-p, --path <path>", "Route path (e.g., /recipe/:id)").option("--params <params>", "Path parameters (e.g., id:string)").option("-o, --output <path>", "Output file path").action(async (name, options) => {
+    const { gorouterAction } = await import("./gorouter-QBMTTFVR.js");
+    await gorouterAction(name, options);
+  })
+).addCommand(
+  new Command5("powersync").description("Generate PowerSync sync rules").argument("<type>", "Type: rules, schema").argument("<table>", "Table name").option("-u, --user-column <column>", "User ID column for sync rules").option("-o, --output <path>", "Output file path").action(async (type, table, options) => {
+    const { powersyncAction } = await import("./powersync-I3LR7TDN.js");
+    await powersyncAction(type, table, options);
+  })
+).addCommand(
+  new Command5("freezed").description("Generate Freezed models").argument("<name>", "Model name").option(
+    "-f, --fields <spec>",
+    "Field specification (e.g., id:String,name:String,email:String?)"
+  ).option("-o, --output <path>", "Output file path").action(async (name, options) => {
+    const { freezedAction } = await import("./freezed-QXFQ4GJC.js");
+    await freezedAction(name, options);
+  })
+).addCommand(
+  new Command5("repository").description("Generate repository pattern").argument("<name>", "Repository name").option("-e, --entity <name>", "Entity name").option("-o, --output <path>", "Output file path").action(async (name, options) => {
+    const { repositoryAction } = await import("./repository-BAOVD3NG.js");
+    await repositoryAction(name, options);
+  })
+);
+
+// src/commands/init/index.ts
+import { existsSync } from "fs";
+import { writeFile } from "fs/promises";
+import { Command as Command6 } from "commander";
+import ora4 from "ora";
+import pc3 from "picocolors";
+var initCommand = new Command6("init").description("Initialize projects and add features").addCommand(
+  new Command6("flutter").description("Initialize a new Flutter project with SaaS stack").argument("<name>", "Project name").action(async (name) => {
+    const spinner = ora4("Creating Flutter project...").start();
+    try {
+      const { exec: exec4 } = await import("child_process");
+      const { promisify: promisify4 } = await import("util");
+      const execAsync4 = promisify4(exec4);
+      await execAsync4(`flutter create ${name}`);
+      spinner.text = "Adding dependencies...";
+      const deps = [
+        "flutter_riverpod",
+        "riverpod_annotation",
+        "go_router",
+        "freezed_annotation",
+        "json_annotation",
+        "supabase_flutter"
+      ];
+      const devDeps = ["riverpod_generator", "build_runner", "freezed", "json_serializable"];
+      process.chdir(name);
+      await execAsync4(`flutter pub add ${deps.join(" ")}`);
+      await execAsync4(`flutter pub add --dev ${devDeps.join(" ")}`);
+      spinner.succeed("Flutter project created");
+      console.log(pc3.green(`
+Project "${name}" created with:`));
+      console.log("  - Riverpod (state management)");
+      console.log("  - GoRouter (navigation)");
+      console.log("  - Freezed (immutable models)");
+      console.log("  - Supabase (backend)");
+      console.log(`
+Next steps:`);
+      console.log(`  cd ${name}`);
+      console.log(`  flutter run`);
+    } catch (error) {
+      spinner.fail("Failed to create Flutter project");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command6("supabase").description("Initialize Supabase in current project").action(async () => {
+    const spinner = ora4("Initializing Supabase...").start();
+    try {
+      const { exec: exec4 } = await import("child_process");
+      const { promisify: promisify4 } = await import("util");
+      const execAsync4 = promisify4(exec4);
+      await execAsync4("supabase init");
+      spinner.succeed("Supabase initialized");
+      console.log(pc3.green("\nSupabase project created"));
+      console.log("Next steps:");
+      console.log("  supabase start");
+      console.log("  supabase db push");
+    } catch (error) {
+      spinner.fail("Failed to initialize Supabase");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command6("worker").description("Initialize a new Cloudflare Worker").argument("<name>", "Worker name").action(async (name) => {
+    const spinner = ora4("Creating Cloudflare Worker...").start();
+    try {
+      const { exec: exec4 } = await import("child_process");
+      const { promisify: promisify4 } = await import("util");
+      const execAsync4 = promisify4(exec4);
+      await execAsync4(`wrangler init ${name}`);
+      spinner.succeed("Cloudflare Worker created");
+      console.log(pc3.green(`
+Worker "${name}" created`));
+      console.log("Next steps:");
+      console.log(`  cd ${name}`);
+      console.log("  wrangler dev");
+    } catch (error) {
+      spinner.fail("Failed to create Worker");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command6("add").description("Add a feature to existing Flutter project").argument("<feature>", "Feature: riverpod, drift, powersync, auth").action(async (feature) => {
+    const spinner = ora4(`Adding ${feature}...`).start();
+    try {
+      const { exec: exec4 } = await import("child_process");
+      const { promisify: promisify4 } = await import("util");
+      const execAsync4 = promisify4(exec4);
+      let deps = [];
+      let devDeps = [];
+      switch (feature) {
+        case "riverpod":
+          deps = ["flutter_riverpod", "riverpod_annotation"];
+          devDeps = ["riverpod_generator", "build_runner"];
+          break;
+        case "drift":
+          deps = ["drift", "sqlite3_flutter_libs", "path_provider", "path"];
+          devDeps = ["drift_dev", "build_runner"];
+          break;
+        case "powersync":
+          deps = ["powersync"];
+          break;
+        case "auth":
+          deps = ["supabase_flutter"];
+          break;
+        default:
+          throw new CLIError(
+            `Unknown feature: "${feature}"`,
+            1,
+            "Valid features: riverpod, drift, powersync, auth"
+          );
+      }
+      if (deps.length > 0) {
+        await execAsync4(`flutter pub add ${deps.join(" ")}`);
+      }
+      if (devDeps.length > 0) {
+        await execAsync4(`flutter pub add --dev ${devDeps.join(" ")}`);
+      }
+      spinner.succeed(`${feature} added`);
+      console.log(pc3.green(`
+${feature} dependencies installed`));
+      if (feature === "riverpod" || feature === "drift") {
+        console.log("Run code generation:");
+        console.log("  dart run build_runner build");
+      }
+    } catch (error) {
+      spinner.fail(`Failed to add ${feature}`);
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command6("config").description("Create saas.yaml config file").action(async () => {
+    const configPath = "saas.yaml";
+    if (existsSync(configPath)) {
+      console.log(pc3.yellow("saas.yaml already exists"));
+      return;
+    }
+    const config = `# SaaS CLI Configuration
+project:
+  name: my-saas-app
+  type: flutter
+
+flutter:
+  path: .
+
+supabase:
+  path: supabase
+  types_output: lib/generated/supabase_types.dart
+
+templates:
+  riverpod:
+    path: lib/features/{feature}/presentation/providers
+  drift:
+    path: lib/features/{feature}/data/datasources/local
+  freezed:
+    path: lib/features/{feature}/domain/entities
+`;
+    await writeFile(configPath, config);
+    console.log(pc3.green("\u2713 Created saas.yaml"));
+  })
+);
+
+// src/commands/push/index.ts
+import { Command as Command7 } from "commander";
+import got2 from "got";
+import ora5 from "ora";
+import pc4 from "picocolors";
+var ONESIGNAL_API = "https://onesignal.com/api/v1";
+async function getOneSignalConfig() {
+  const appId = process.env.ONESIGNAL_APP_ID;
+  const apiKey = process.env.ONESIGNAL_API_KEY;
+  if (!appId || !apiKey) {
+    const config = await loadGlobalConfig();
+    return {
+      appId: appId || config.onesignal?.appId,
+      apiKey: apiKey || config.onesignal?.apiKey
+    };
+  }
+  return { appId, apiKey };
+}
+async function sendNotification(target, message, data, scheduleAt) {
+  const { appId, apiKey } = await getOneSignalConfig();
+  if (!appId || !apiKey) {
+    throw new AuthError(
+      "OneSignal credentials not found",
+      "Set ONESIGNAL_APP_ID and ONESIGNAL_API_KEY environment variables"
+    );
+  }
+  const payload = {
+    app_id: appId,
+    contents: { en: message }
+  };
+  if (target.userId) {
+    payload.include_external_user_ids = [target.userId];
+  } else if (target.segment) {
+    payload.included_segments = [target.segment];
+  }
+  if (data) {
+    payload.data = data;
+  }
+  if (scheduleAt) {
+    payload.send_after = scheduleAt;
+  }
+  const response = await got2.post(`${ONESIGNAL_API}/notifications`, {
+    headers: {
+      Authorization: `Basic ${apiKey}`,
+      "Content-Type": "application/json"
+    },
+    json: payload
+  }).json();
+  return response;
+}
+var pushCommand = new Command7("push").description("OneSignal push notification management").addCommand(
+  new Command7("send").description("Send a push notification").argument("<target>", "User ID or segment name").argument("<message>", "Notification message").option("-s, --segment", "Target is a segment name").option("-d, --data <json>", "Additional data (JSON)").action(async (target, message, options) => {
+    const spinner = ora5("Sending notification...").start();
+    try {
+      const data = options.data ? JSON.parse(options.data) : void 0;
+      const targetObj = options.segment ? { segment: target } : { userId: target };
+      const result = await sendNotification(targetObj, message, data);
+      spinner.succeed("Notification sent");
+      console.log(pc4.green(`ID: ${result.id}`));
+      console.log(pc4.dim(`Recipients: ${result.recipients}`));
+    } catch (error) {
+      spinner.fail("Failed to send notification");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command7("schedule").description("Schedule a push notification").argument("<target>", "User ID").argument("<message>", "Notification message").option(
+    "--at <datetime>",
+    "Send time (ISO 8601 format)",
+    new Date(Date.now() + 36e5).toISOString()
+  ).option("-d, --data <json>", "Additional data (JSON)").action(async (target, message, options) => {
+    const spinner = ora5("Scheduling notification...").start();
+    try {
+      const data = options.data ? JSON.parse(options.data) : void 0;
+      const result = await sendNotification({ userId: target }, message, data, options.at);
+      spinner.succeed("Notification scheduled");
+      console.log(pc4.green(`ID: ${result.id}`));
+      console.log(pc4.dim(`Scheduled for: ${options.at}`));
+    } catch (error) {
+      spinner.fail("Failed to schedule notification");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command7("template").description("Template operations").argument("<action>", "Action: list, send").argument("[templateId]", "Template ID (for send)").option("--to <userId>", "Target user ID (for send)").action(async (action, templateId, options) => {
+    const spinner = ora5(`Template ${action}...`).start();
+    try {
+      const { appId, apiKey } = await getOneSignalConfig();
+      if (!appId || !apiKey) {
+        throw new AuthError(
+          "OneSignal credentials not found",
+          "Set ONESIGNAL_APP_ID and ONESIGNAL_API_KEY environment variables"
+        );
+      }
+      if (action === "list") {
+        const response = await got2.get(`${ONESIGNAL_API}/templates?app_id=${appId}`, {
+          headers: { Authorization: `Basic ${apiKey}` }
+        }).json();
+        spinner.stop();
+        console.log(pc4.cyan("Templates:"));
+        for (const template of response.templates) {
+          console.log(`  ${pc4.green(template.id)} - ${template.name}`);
+        }
+      } else if (action === "send") {
+        if (!templateId || !options.to) {
+          throw new Error("Template ID and target user required");
+        }
+        const response = await got2.post(`${ONESIGNAL_API}/notifications`, {
+          headers: {
+            Authorization: `Basic ${apiKey}`,
+            "Content-Type": "application/json"
+          },
+          json: {
+            app_id: appId,
+            template_id: templateId,
+            include_external_user_ids: [options.to]
+          }
+        }).json();
+        spinner.succeed("Template notification sent");
+        console.log(pc4.green(`ID: ${response.id}`));
+      }
+    } catch (error) {
+      spinner.fail(`Template ${action} failed`);
+      handleError(error);
+    }
+  })
+);
+
+// src/commands/redis/index.ts
+import { Command as Command8 } from "commander";
+import ora6 from "ora";
+import pc5 from "picocolors";
+async function getRedisUrl() {
+  const url = process.env.REDIS_URL;
+  if (!url) {
+    const config = await loadGlobalConfig();
+    if (config.redis?.url) {
+      return config.redis.url;
+    }
+    throw new AuthError(
+      "REDIS_URL environment variable is not set",
+      "Set REDIS_URL to your Redis/DragonflyDB connection string"
+    );
+  }
+  return url;
+}
+var redisCommand = new Command8("redis").description("Redis/DragonflyDB cache and queue management").addCommand(
+  new Command8("ping").description("Test Redis connection").action(async () => {
+    const spinner = ora6("Pinging Redis...").start();
+    try {
+      const url = await getRedisUrl();
+      spinner.succeed(`Connected to Redis at ${url.replace(/:[^:]+@/, ":****@")}`);
+      console.log(pc5.green("PONG"));
+    } catch (error) {
+      spinner.fail("Failed to connect to Redis");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command8("info").description("Get Redis server info").action(async () => {
+    const spinner = ora6("Fetching Redis info...").start();
+    try {
+      await getRedisUrl();
+      spinner.stop();
+      console.log(pc5.yellow("Note: Full Redis info requires ioredis integration"));
+      console.log("Install ioredis for full functionality: pnpm add ioredis");
+    } catch (error) {
+      spinner.fail("Failed to get Redis info");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command8("keys").description("List keys matching pattern").argument("<pattern>", "Key pattern (e.g., user:*)").action(async (pattern) => {
+    const spinner = ora6(`Searching keys: ${pattern}...`).start();
+    try {
+      await getRedisUrl();
+      spinner.stop();
+      console.log(pc5.yellow("Note: Key listing requires ioredis integration"));
+    } catch (error) {
+      spinner.fail("Failed to list keys");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command8("get").description("Get value by key").argument("<key>", "Key name").action(async (_key) => {
+    try {
+      await getRedisUrl();
+      console.log(pc5.yellow("Note: Get operation requires ioredis integration"));
+    } catch (error) {
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command8("set").description("Set a key-value pair").argument("<key>", "Key name").argument("<value>", "Value").option("--ttl <seconds>", "Time to live in seconds").action(async (_key, _value, _options) => {
+    try {
+      await getRedisUrl();
+      console.log(pc5.yellow("Note: Set operation requires ioredis integration"));
+    } catch (error) {
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command8("del").description("Delete a key").argument("<key>", "Key name").action(async (_key) => {
+    try {
+      await getRedisUrl();
+      console.log(pc5.yellow("Note: Delete operation requires ioredis integration"));
+    } catch (error) {
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command8("queue").description("BullMQ queue operations").argument("<name>", "Queue name").argument(
+    "[action]",
+    "Action: status, waiting, active, failed, delayed, pause, resume, clean"
+  ).option("--status <status>", "Job status for clean action").option("--age <hours>", "Job age in hours for clean action").action(async (name, action = "status", _options) => {
+    const spinner = ora6(`Queue ${name}: ${action}...`).start();
+    try {
+      await getRedisUrl();
+      spinner.stop();
+      if (action === "status") {
+        console.log(pc5.cyan(`Queue: ${name}`));
+        console.log(
+          formatTable(
+            ["Status", "Count"],
+            [
+              ["waiting", "0"],
+              ["active", "0"],
+              ["completed", "0"],
+              ["failed", "0"],
+              ["delayed", "0"]
+            ]
+          )
+        );
+      }
+      console.log(pc5.yellow("\nNote: Full BullMQ integration requires bullmq package"));
+    } catch (error) {
+      spinner.fail(`Queue operation failed`);
+      handleError(error);
+    }
+  })
+);
+
+// src/commands/supabase/index.ts
+import { Command as Command9 } from "commander";
+import ora7 from "ora";
+import pc6 from "picocolors";
+
+// src/services/supabase.ts
+import { exec as exec2 } from "child_process";
+import { promisify as promisify2 } from "util";
+var execAsync2 = promisify2(exec2);
+async function checkSupabaseCLI() {
+  try {
+    await execAsync2("supabase --version");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runSupabaseCommand(args) {
+  const isInstalled = await checkSupabaseCLI();
+  if (!isInstalled) {
+    throw new CLIError(
+      "Supabase CLI not found",
+      1,
+      "Install with: brew install supabase/tap/supabase"
+    );
+  }
+  try {
+    const { stdout, stderr } = await execAsync2(`supabase ${args.join(" ")}`);
+    if (stderr && !stderr.includes("warning")) {
+      console.error(stderr);
+    }
+    return stdout;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CLIError(`Supabase command failed: ${message}`);
+  }
+}
+var RLS_POLICIES = {
+  "user-owned": (table, column) => `
+-- RLS Policies for ${table} (user-owned)
+
+-- Enable RLS
+ALTER TABLE ${table} ENABLE ROW LEVEL SECURITY;
+
+-- Users can view their own records
+CREATE POLICY "Users can view own ${table}"
+  ON ${table} FOR SELECT
+  USING (auth.uid() = ${column});
+
+-- Users can create their own records
+CREATE POLICY "Users can create own ${table}"
+  ON ${table} FOR INSERT
+  WITH CHECK (auth.uid() = ${column});
+
+-- Users can update their own records
+CREATE POLICY "Users can update own ${table}"
+  ON ${table} FOR UPDATE
+  USING (auth.uid() = ${column});
+
+-- Users can delete their own records
+CREATE POLICY "Users can delete own ${table}"
+  ON ${table} FOR DELETE
+  USING (auth.uid() = ${column});
+`,
+  "team-owned": (table, teamColumn) => `
+-- RLS Policies for ${table} (team-owned)
+
+-- Enable RLS
+ALTER TABLE ${table} ENABLE ROW LEVEL SECURITY;
+
+-- Team members can view team records
+CREATE POLICY "Team members can view ${table}"
+  ON ${table} FOR SELECT
+  USING (
+    ${teamColumn} IN (
+      SELECT team_id FROM team_members WHERE user_id = auth.uid()
+    )
+  );
+
+-- Team members can create team records
+CREATE POLICY "Team members can create ${table}"
+  ON ${table} FOR INSERT
+  WITH CHECK (
+    ${teamColumn} IN (
+      SELECT team_id FROM team_members WHERE user_id = auth.uid()
+    )
+  );
+
+-- Team members can update team records
+CREATE POLICY "Team members can update ${table}"
+  ON ${table} FOR UPDATE
+  USING (
+    ${teamColumn} IN (
+      SELECT team_id FROM team_members WHERE user_id = auth.uid()
+    )
+  );
+
+-- Team admins can delete team records
+CREATE POLICY "Team admins can delete ${table}"
+  ON ${table} FOR DELETE
+  USING (
+    ${teamColumn} IN (
+      SELECT team_id FROM team_members WHERE user_id = auth.uid() AND role = 'admin'
+    )
+  );
+`,
+  "public-read": (table) => `
+-- RLS Policies for ${table} (public-read)
+
+-- Enable RLS
+ALTER TABLE ${table} ENABLE ROW LEVEL SECURITY;
+
+-- Anyone can view records
+CREATE POLICY "Anyone can view ${table}"
+  ON ${table} FOR SELECT
+  USING (true);
+
+-- Only authenticated users can create records
+CREATE POLICY "Authenticated users can create ${table}"
+  ON ${table} FOR INSERT
+  WITH CHECK (auth.role() = 'authenticated');
+
+-- Only owners can update their records
+CREATE POLICY "Owners can update ${table}"
+  ON ${table} FOR UPDATE
+  USING (auth.uid() = user_id);
+
+-- Only owners can delete their records
+CREATE POLICY "Owners can delete ${table}"
+  ON ${table} FOR DELETE
+  USING (auth.uid() = user_id);
+`,
+  "admin-only": (table) => `
+-- RLS Policies for ${table} (admin-only)
+
+-- Enable RLS
+ALTER TABLE ${table} ENABLE ROW LEVEL SECURITY;
+
+-- Only admins can view records
+CREATE POLICY "Admins can view ${table}"
+  ON ${table} FOR SELECT
+  USING (
+    auth.uid() IN (SELECT user_id FROM admins)
+  );
+
+-- Only admins can create records
+CREATE POLICY "Admins can create ${table}"
+  ON ${table} FOR INSERT
+  WITH CHECK (
+    auth.uid() IN (SELECT user_id FROM admins)
+  );
+
+-- Only admins can update records
+CREATE POLICY "Admins can update ${table}"
+  ON ${table} FOR UPDATE
+  USING (
+    auth.uid() IN (SELECT user_id FROM admins)
+  );
+
+-- Only admins can delete records
+CREATE POLICY "Admins can delete ${table}"
+  ON ${table} FOR DELETE
+  USING (
+    auth.uid() IN (SELECT user_id FROM admins)
+  );
+`
+};
+
+// src/commands/supabase/index.ts
+var supabaseCommand = new Command9("supabase").description("Supabase database management").addCommand(
+  new Command9("schema").description("Show database schema").argument("[table]", "Specific table name").option("--rls", "Include RLS policies").option("--relationships", "Show foreign key relationships").action(async (_table, _options) => {
+    const spinner = ora7("Fetching schema...").start();
+    try {
+      const output = await runSupabaseCommand(["db", "dump", "--schema", "public", "-f", "-"]);
+      spinner.stop();
+      console.log(output);
+    } catch (error) {
+      spinner.fail("Failed to fetch schema");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command9("create-table").description("Generate CREATE TABLE SQL").argument("<name>", "Table name").option("-c, --columns <spec>", "Column specification").option("--from-freezed <file>", "Generate from Freezed model file").action(async (name, options) => {
+    try {
+      if (!options.columns) {
+        throw new CLIError(
+          "Columns specification required",
+          1,
+          'Use --columns "id:uuid:pk,title:text,user_id:uuid:fk(auth.users)"'
+        );
+      }
+      const columns = parseColumnSpec(options.columns);
+      const sql = columnsToSQL(name, columns);
+      console.log(pc6.cyan("-- Migration: create_" + name + "_table"));
+      console.log(sql);
+      console.log("\n-- Enable RLS");
+      console.log(`ALTER TABLE ${name} ENABLE ROW LEVEL SECURITY;`);
+    } catch (error) {
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command9("rls").description("Generate RLS policies").argument("<table>", "Table name").option(
+    "-p, --policy <type>",
+    "Policy type: user-owned, team-owned, public-read, admin-only",
+    "user-owned"
+  ).option("-c, --column <name>", "User/team ID column", "user_id").action(async (table, options) => {
+    try {
+      const policyType = options.policy;
+      if (!RLS_POLICIES[policyType]) {
+        throw new CLIError(
+          `Invalid policy type: "${policyType}"`,
+          1,
+          "Valid types: user-owned, team-owned, public-read, admin-only"
+        );
+      }
+      const sql = RLS_POLICIES[policyType](table, options.column);
+      console.log(sql);
+    } catch (error) {
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command9("migration").description("Migration management").argument("<action>", "Action: new, apply, status").argument("[name]", "Migration name (for new)").action(async (action, name) => {
+    const spinner = ora7(`Running migration ${action}...`).start();
+    try {
+      let args;
+      switch (action) {
+        case "new":
+          if (!name) {
+            throw new CLIError('Migration name required for "new" action');
+          }
+          args = ["migration", "new", name];
+          break;
+        case "apply":
+          args = ["db", "push"];
+          break;
+        case "status":
+          args = ["migration", "list"];
+          break;
+        default:
+          throw new CLIError(
+            `Invalid action: "${action}"`,
+            1,
+            "Valid actions: new, apply, status"
+          );
+      }
+      const output = await runSupabaseCommand(args);
+      spinner.stop();
+      console.log(output);
+    } catch (error) {
+      spinner.fail(`Migration ${action} failed`);
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command9("types").description("Generate TypeScript/Dart types").argument("<lang>", "Language: dart, typescript").option("-o, --output <path>", "Output file path").action(async (lang, options) => {
+    const spinner = ora7(`Generating ${lang} types...`).start();
+    try {
+      let args;
+      switch (lang) {
+        case "dart":
+        case "typescript":
+          args = ["gen", "types", lang, "--local"];
+          break;
+        default:
+          throw new CLIError(
+            `Invalid language: "${lang}"`,
+            1,
+            "Valid languages: dart, typescript"
+          );
+      }
+      const output = await runSupabaseCommand(args);
+      spinner.stop();
+      if (options.output) {
+        const { writeFile: writeFile2 } = await import("fs/promises");
+        await writeFile2(options.output, output);
+        console.log(pc6.green(`\u2713 Generated ${options.output}`));
+      } else {
+        console.log(output);
+      }
+    } catch (error) {
+      spinner.fail("Type generation failed");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command9("fn").description("Edge function management").argument("<action>", "Action: new, deploy, logs").argument("<name>", "Function name").action(async (action, name) => {
+    const spinner = ora7(`Running fn ${action}...`).start();
+    try {
+      let args;
+      switch (action) {
+        case "new":
+          args = ["functions", "new", name];
+          break;
+        case "deploy":
+          args = ["functions", "deploy", name];
+          break;
+        case "logs":
+          args = ["functions", "logs", name];
+          break;
+        default:
+          throw new CLIError(
+            `Invalid action: "${action}"`,
+            1,
+            "Valid actions: new, deploy, logs"
+          );
+      }
+      const output = await runSupabaseCommand(args);
+      spinner.stop();
+      console.log(output);
+    } catch (error) {
+      spinner.fail(`Function ${action} failed`);
+      handleError(error);
+    }
+  })
+);
+
+// src/commands/video/index.ts
+import { exec as exec3 } from "child_process";
+import { promisify as promisify3 } from "util";
+import { Command as Command10 } from "commander";
+import ora8 from "ora";
+import pc7 from "picocolors";
+var execAsync3 = promisify3(exec3);
+async function checkFFmpeg() {
+  try {
+    await execAsync3("ffmpeg -version");
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function runFFmpeg(args) {
+  const isInstalled = await checkFFmpeg();
+  if (!isInstalled) {
+    throw new CLIError(
+      "FFmpeg not found",
+      1,
+      "Install FFmpeg: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)"
+    );
+  }
+  try {
+    const { stdout, stderr } = await execAsync3(`ffmpeg ${args.join(" ")}`);
+    return stdout || stderr;
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    throw new CLIError(`FFmpeg command failed: ${message}`);
+  }
+}
+async function runFFprobe(args) {
+  const isInstalled = await checkFFmpeg();
+  if (!isInstalled) {
+    throw new CLIError(
+      "FFmpeg/FFprobe not found",
+      1,
+      "Install FFmpeg: brew install ffmpeg (macOS) or apt install ffmpeg (Linux)"
+    );
+  }
+  try {
+    const { stdout } = await execAsync3(`ffprobe ${args.join(" ")}`);
+    return stdout;
+  } catch (error) {
+    const err = error;
+    return err.stderr || "";
+  }
+}
+var videoCommand = new Command10("video").description("Video processing with FFmpeg").addCommand(
+  new Command10("info").description("Get video file information").argument("<file>", "Video file path").action(async (file) => {
+    const spinner = ora8("Analyzing video...").start();
+    try {
+      const output = await runFFprobe([
+        "-v",
+        "quiet",
+        "-print_format",
+        "json",
+        "-show_format",
+        "-show_streams",
+        `"${file}"`
+      ]);
+      spinner.stop();
+      try {
+        const info = JSON.parse(output);
+        const format = info.format || {};
+        const videoStream = info.streams?.find((s) => s.codec_type === "video") || {};
+        const audioStream = info.streams?.find((s) => s.codec_type === "audio") || {};
+        console.log(pc7.cyan("Video Information:"));
+        console.log(`  File: ${format.filename || file}`);
+        console.log(
+          `  Duration: ${format.duration ? Number.parseFloat(format.duration).toFixed(2) + "s" : "N/A"}`
+        );
+        console.log(
+          `  Size: ${format.size ? (Number.parseInt(format.size, 10) / 1024 / 1024).toFixed(2) + " MB" : "N/A"}`
+        );
+        console.log(
+          `  Bitrate: ${format.bit_rate ? (Number.parseInt(format.bit_rate, 10) / 1e3).toFixed(0) + " kbps" : "N/A"}`
+        );
+        if (videoStream.width) {
+          console.log(pc7.cyan("\nVideo Stream:"));
+          console.log(`  Resolution: ${videoStream.width}x${videoStream.height}`);
+          console.log(`  Codec: ${videoStream.codec_name || "N/A"}`);
+          console.log(`  FPS: ${videoStream.r_frame_rate || "N/A"}`);
+        }
+        if (audioStream.codec_name) {
+          console.log(pc7.cyan("\nAudio Stream:"));
+          console.log(`  Codec: ${audioStream.codec_name}`);
+          console.log(`  Sample Rate: ${audioStream.sample_rate || "N/A"} Hz`);
+          console.log(`  Channels: ${audioStream.channels || "N/A"}`);
+        }
+      } catch {
+        console.log(output);
+      }
+    } catch (error) {
+      spinner.fail("Failed to analyze video");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command10("combine").description("Combine video and audio").argument("<video>", "Video file path").argument("<audio>", "Audio file path").requiredOption("-o, --output <file>", "Output file path").action(async (video, audio, options) => {
+    const spinner = ora8("Combining video and audio...").start();
+    try {
+      await runFFmpeg([
+        "-i",
+        `"${video}"`,
+        "-i",
+        `"${audio}"`,
+        "-c:v",
+        "copy",
+        "-c:a",
+        "aac",
+        "-y",
+        `"${options.output}"`
+      ]);
+      spinner.succeed(`Combined: ${options.output}`);
+    } catch (error) {
+      spinner.fail("Failed to combine video and audio");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command10("thumbnail").description("Extract thumbnail from video").argument("<video>", "Video file path").option("--at <timestamp>", "Timestamp (e.g., 00:00:05)", "00:00:01").requiredOption("-o, --output <file>", "Output file path").action(async (video, options) => {
+    const spinner = ora8("Extracting thumbnail...").start();
+    try {
+      await runFFmpeg([
+        "-i",
+        `"${video}"`,
+        "-ss",
+        options.at,
+        "-vframes",
+        "1",
+        "-y",
+        `"${options.output}"`
+      ]);
+      spinner.succeed(`Thumbnail: ${options.output}`);
+    } catch (error) {
+      spinner.fail("Failed to extract thumbnail");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command10("resize").description("Resize video").argument("<video>", "Video file path").requiredOption("-s, --size <WxH>", "New size (e.g., 1280x720)").requiredOption("-o, --output <file>", "Output file path").action(async (video, options) => {
+    const spinner = ora8("Resizing video...").start();
+    try {
+      await runFFmpeg([
+        "-i",
+        `"${video}"`,
+        "-vf",
+        `scale=${options.size}`,
+        "-y",
+        `"${options.output}"`
+      ]);
+      spinner.succeed(`Resized: ${options.output}`);
+    } catch (error) {
+      spinner.fail("Failed to resize video");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command10("compress").description("Compress video").argument("<video>", "Video file path").option("-q, --quality <crf>", "Quality (1-51, lower is better)", "23").requiredOption("-o, --output <file>", "Output file path").action(async (video, options) => {
+    const spinner = ora8("Compressing video...").start();
+    try {
+      await runFFmpeg([
+        "-i",
+        `"${video}"`,
+        "-c:v",
+        "libx264",
+        "-crf",
+        options.quality,
+        "-preset",
+        "medium",
+        "-y",
+        `"${options.output}"`
+      ]);
+      spinner.succeed(`Compressed: ${options.output}`);
+    } catch (error) {
+      spinner.fail("Failed to compress video");
+      handleError(error);
+    }
+  })
+).addCommand(
+  new Command10("trim").description("Trim video").argument("<video>", "Video file path").requiredOption("--start <time>", "Start time (e.g., 00:00:10)").requiredOption("--end <time>", "End time (e.g., 00:01:00)").requiredOption("-o, --output <file>", "Output file path").action(async (video, options) => {
+    const spinner = ora8("Trimming video...").start();
+    try {
+      await runFFmpeg([
+        "-i",
+        `"${video}"`,
+        "-ss",
+        options.start,
+        "-to",
+        options.end,
+        "-c",
+        "copy",
+        "-y",
+        `"${options.output}"`
+      ]);
+      spinner.succeed(`Trimmed: ${options.output}`);
+    } catch (error) {
+      spinner.fail("Failed to trim video");
+      handleError(error);
+    }
+  })
+);
+
+// src/cli.ts
+var VERSION = "1.0.0";
+function createProgram() {
+  const program = new Command11();
+  program.name("saas").description("A unified CLI for Flutter SaaS development").version(VERSION, "-V, --version", "Display version number").configureHelp({
+    sortSubcommands: true,
+    sortOptions: true
+  }).option("--json", "Output results as JSON").option("-v, --verbose", "Enable verbose output").option("--debug", "Enable debug output").hook("preAction", (thisCommand) => {
+    const opts = thisCommand.opts();
+    process.env.SAAS_CLI_JSON = opts.json ? "1" : "";
+    process.env.SAAS_CLI_VERBOSE = opts.verbose ? "1" : "";
+    process.env.SAAS_CLI_DEBUG = opts.debug ? "1" : "";
+  });
+  program.addCommand(docsCommand);
+  program.addCommand(askCommand);
+  program.addCommand(genCommand);
+  program.addCommand(supabaseCommand);
+  program.addCommand(redisCommand);
+  program.addCommand(cfCommand);
+  program.addCommand(pushCommand);
+  program.addCommand(flagsCommand);
+  program.addCommand(videoCommand);
+  program.addCommand(initCommand);
+  program.addHelpText(
+    "after",
+    `
+${pc8.cyan("Examples:")}
+  ${pc8.dim("# Look up Flutter documentation")}
+  $ saas docs flutter "ListView.builder with pagination"
+
+  ${pc8.dim("# Ask AI a question")}
+  $ saas ask "best practices for offline-first Flutter apps"
+
+  ${pc8.dim("# Generate a Riverpod notifier")}
+  $ saas gen riverpod notifier UserList --state "List<User>"
+
+  ${pc8.dim("# Generate RLS policies")}
+  $ saas supabase rls recipes --policy user-owned --column user_id
+
+  ${pc8.dim("# Check feature flag status")}
+  $ saas flags list
+
+${pc8.cyan("Documentation:")}
+  https://github.com/your-username/saas-cli
+`
+  );
+  return program;
+}
+async function run() {
+  const program = createProgram();
+  try {
+    await program.parseAsync(process.argv);
+  } catch (error) {
+    handleError(error);
+  }
+}
+
+// src/index.ts
+run();
+//# sourceMappingURL=index.js.map