@runa-ai/runa-cli 0.5.72 → 0.6.0

package/dist/watch-UCDVOQAH.js

@@ -0,0 +1,911 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { registerCleanup } from './chunk-TYIAD6SB.js';
+import { isNonInteractiveEnabled, assertTtyRequired } from './chunk-6Y3LAUGL.js';
+import { getDatabasePackagePath } from './chunk-5NKWR4FF.js';
+import './chunk-JMJP4A47.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import path, { basename } from 'path';
+import { createCLILogger, CLIError, detectDatabasePackage, DATABASE_PACKAGE_CANDIDATES } from '@runa-ai/runa';
+import chalk from 'chalk';
+import { Command } from 'commander';
+import { watch } from 'chokidar';
+import notifier from 'node-notifier';
+import { existsSync } from 'fs';
+import { readFile } from 'fs/promises';
+import { execa } from 'execa';
+import { glob } from 'glob';
+
+createRequire(import.meta.url);
+
+// src/commands/watch.ts
+init_esm_shims();
+
+// src/watchers/schema-watcher.ts
+init_esm_shims();
+
+// src/notifiers/desktop-notifier.ts
+init_esm_shims();
+var logger = createCLILogger("notifier");
+async function notifyDesktop(options) {
+  if (process.env.CI === "true") {
+    return;
+  }
+  const { title, message, type = "info", timeout = 5 } = options;
+  try {
+    const iconMap = {
+      info: "\u2139\uFE0F",
+      success: "\u2705",
+      warning: "\u26A0\uFE0F",
+      error: "\u274C"
+    };
+    const icon = iconMap[type];
+    const fullTitle = `${icon} ${title}`;
+    notifier.notify({
+      title: fullTitle,
+      message,
+      timeout: timeout * 1e3,
+      // Convert to milliseconds
+      wait: false
+    });
+  } catch (error) {
+    logger.debug(`Notification failed: ${error}`);
+  }
+}
+
+// src/validators/schema-validator.ts
+init_esm_shims();
+var RE_DOLLAR_TAG = /\$([a-zA-Z_][a-zA-Z0-9_]*)?\$/y;
+function maskLiteralChar(char) {
+  return char === "\n" ? "\n" : " ";
+}
+function appendSpaces(state, count) {
+  state.result += " ".repeat(count);
+}
+function consumeLineComment(content, state) {
+  if (state.inSingleQuote || state.inDoubleQuote || state.inDollarQuote) return false;
+  if (content[state.i] !== "-" || content[state.i + 1] !== "-") return false;
+  appendSpaces(state, 2);
+  state.i += 2;
+  while (state.i < content.length && content[state.i] !== "\n") {
+    state.result += " ";
+    state.i += 1;
+  }
+  return true;
+}
+function consumeBlockComment(content, state) {
+  if (state.inSingleQuote || state.inDoubleQuote || state.inDollarQuote) return false;
+  if (content[state.i] !== "/" || content[state.i + 1] !== "*") return false;
+  appendSpaces(state, 2);
+  state.i += 2;
+  while (state.i < content.length) {
+    const blockChar = content[state.i] ?? "";
+    if (blockChar === "*" && content[state.i + 1] === "/") {
+      appendSpaces(state, 2);
+      state.i += 2;
+      break;
+    }
+    state.result += blockChar === "\n" ? "\n" : " ";
+    state.i += 1;
+  }
+  return true;
+}
+function toggleSingleQuote(content, state) {
+  if (state.inDoubleQuote || state.inDollarQuote || content[state.i] !== "'") return false;
+  if (state.inSingleQuote && content[state.i + 1] === "'") {
+    state.result += `''`;
+    state.i += 2;
+    return true;
+  }
+  state.inSingleQuote = !state.inSingleQuote;
+  state.result += " ";
+  state.i += 1;
+  return true;
+}
+function toggleDoubleQuote(content, state) {
+  if (state.inSingleQuote || state.inDollarQuote || content[state.i] !== '"') return false;
+  if (state.inDoubleQuote && content[state.i + 1] === '"') {
+    state.result += '""';
+    state.i += 2;
+    return true;
+  }
+  state.inDoubleQuote = !state.inDoubleQuote;
+  state.result += " ";
+  state.i += 1;
+  return true;
+}
+function consumeDollarQuoteBoundary(content, state) {
+  if (state.inSingleQuote || state.inDoubleQuote || content[state.i] !== "$") return false;
+  if (state.inDollarQuote) {
+    const closeTag = `$${state.dollarTag}$`;
+    if (!content.startsWith(closeTag, state.i)) return false;
+    state.inDollarQuote = false;
+    state.dollarTag = "";
+    appendSpaces(state, closeTag.length);
+    state.i += closeTag.length;
+    return true;
+  }
+  RE_DOLLAR_TAG.lastIndex = state.i;
+  const tagMatch = RE_DOLLAR_TAG.exec(content);
+  if (!tagMatch) return false;
+  state.inDollarQuote = true;
+  state.dollarTag = tagMatch[1] ?? "";
+  appendSpaces(state, tagMatch[0].length);
+  state.i += tagMatch[0].length;
+  return true;
+}
+function consumeLiteralBody(content, state) {
+  if (!state.inSingleQuote && !state.inDoubleQuote && !state.inDollarQuote) return false;
+  state.result += maskLiteralChar(content[state.i]);
+  state.i += 1;
+  return true;
+}
+function stripSqlCommentsAndLiterals(content) {
+  const state = {
+    result: "",
+    i: 0,
+    inSingleQuote: false,
+    inDoubleQuote: false,
+    inDollarQuote: false,
+    dollarTag: ""
+  };
+  while (state.i < content.length) {
+    if (consumeLineComment(content, state)) continue;
+    if (consumeBlockComment(content, state)) continue;
+    if (toggleSingleQuote(content, state)) continue;
+    if (toggleDoubleQuote(content, state)) continue;
+    if (consumeDollarQuoteBoundary(content, state)) continue;
+    if (consumeLiteralBody(content, state)) continue;
+    state.result += content[state.i] ?? "";
+    state.i += 1;
+  }
+  return state.result;
+}
+function extractStatements(sql) {
+  const cleaned = stripSqlCommentsAndLiterals(sql);
+  const statements = cleaned.split(";");
+  return statements.map((stmt) => stmt.trim()).filter((stmt) => stmt.length > 0);
+}
+function tableHasColumn(tableBody, columnName) {
+  const escapedColumnName = columnName.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+  const target = `\\b${escapedColumnName}\\b`;
+  const colRe = new RegExp(target, "i");
+  return colRe.test(tableBody);
+}
+async function validateSchemaFile(filePath) {
+  const errors = [];
+  const warnings = [];
+  try {
+    if (!existsSync(filePath)) {
+      errors.push(`File not found: ${filePath}`);
+      return { isValid: false, errors, warnings };
+    }
+    const content = await readFile(filePath, "utf-8");
+    if (filePath.endsWith(".ts") || filePath.endsWith(".tsx")) {
+      validateDrizzleSchema(content, errors, warnings);
+    } else if (filePath.endsWith(".sql")) {
+      validateSqlSchema(content, errors, warnings);
+    } else {
+      warnings.push(`Unknown file type: ${filePath}`);
+    }
+    return {
+      isValid: errors.length === 0,
+      errors,
+      warnings
+    };
+  } catch (error) {
+    errors.push(`Validation error: ${error}`);
+    return { isValid: false, errors, warnings };
+  }
+}
+function validateDrizzleSchema(content, _errors, warnings) {
+  if (!content.includes("drizzle-orm")) {
+    warnings.push("Missing drizzle-orm import");
+  }
+  if (!content.includes(".table(")) {
+    warnings.push("No table definitions found");
+  }
+  if (content.includes(".table(")) {
+    if (!content.includes("id:")) {
+      warnings.push("Table missing id column");
+    }
+    if (!content.includes("createdAt:") && !content.includes("created_at:")) {
+      warnings.push("Table missing createdAt column");
+    }
+    if (!content.includes("updatedAt:") && !content.includes("updated_at:")) {
+      warnings.push("Table missing updatedAt column");
+    }
+  }
+  if (/\bany\b/.test(content)) {
+    warnings.push('Usage of "any" type detected - prefer specific types');
+  }
+}
+function checkIdempotence(content, errors, warnings) {
+  for (const statement of extractStatements(content)) {
+    if (/^CREATE\s+TABLE/i.test(statement) && !/\bIF\s+NOT\s+EXISTS\b/i.test(statement)) {
+      errors.push("CREATE TABLE without IF NOT EXISTS - not idempotent");
+      break;
+    }
+    if (/^CREATE\s+INDEX/i.test(statement) && !/\bIF\s+NOT\s+EXISTS\b/i.test(statement)) {
+      warnings.push("CREATE INDEX without IF NOT EXISTS - not idempotent");
+      break;
+    }
+  }
+}
+function checkDangerousOperations(content, errors) {
+  const cleaned = stripSqlCommentsAndLiterals(content);
+  if (/\bDROP\s+TABLE\b/i.test(cleaned) && !/\b_deprecated_\b/i.test(cleaned)) {
+    errors.push("DROP TABLE detected - use _deprecated_ prefix instead");
+  }
+  if (/\bDROP\s+COLUMN\b/i.test(cleaned)) {
+    errors.push("DROP COLUMN detected - use _deprecated_ prefix instead");
+  }
+}
+function checkDocumentation(content, warnings) {
+  if (!/AI HINT/i.test(content) && content.length > 100) {
+    warnings.push("Missing AI HINT comment for documentation");
+  }
+}
+function checkMandatoryColumns(content, warnings) {
+  const cleaned = stripSqlCommentsAndLiterals(content);
+  const statements = extractStatements(cleaned);
+  for (const statement of statements) {
+    if (!/^\s*CREATE\s+TABLE\b/i.test(statement)) {
+      continue;
+    }
+    const openParen = statement.indexOf("(");
+    if (openParen === -1) {
+      continue;
+    }
+    const closeParen = statement.lastIndexOf(")");
+    if (closeParen === -1 || closeParen <= openParen) {
+      continue;
+    }
+    const body = statement.slice(openParen + 1, closeParen);
+    if (!tableHasColumn(body, "id")) {
+      warnings.push("Table missing id column");
+    }
+    if (!tableHasColumn(body, "created_at")) {
+      warnings.push("Table missing created_at column");
+    }
+    if (!tableHasColumn(body, "updated_at")) {
+      warnings.push("Table missing updated_at column");
+    }
+  }
+}
+function validateSqlSchema(content, errors, warnings) {
+  checkIdempotence(content, errors, warnings);
+  checkDangerousOperations(content, errors);
+  checkDocumentation(content, warnings);
+  checkMandatoryColumns(content, warnings);
+}
+
+// src/watchers/schema-watcher.ts
+var riskDetectorLoader = null;
+function loadRiskDetectorModule() {
+  if (!riskDetectorLoader) {
+    riskDetectorLoader = import('./risk-detector-BXUY2WKS.js').then((module) => ({
+      detectSchemaRisks: module.detectSchemaRisks
+    })).catch((error) => {
+      riskDetectorLoader = null;
+      throw error;
+    });
+  }
+  return riskDetectorLoader;
+}
+var SchemaWatcher = class {
+  watcher = null;
+  logger = createCLILogger("schema-watcher");
+  debounceTimers = /* @__PURE__ */ new Map();
+  options;
+  constructor(options) {
+    this.options = {
+      patterns: options.patterns,
+      ignored: options.ignored || ["**/node_modules/**", "**/.git/**"],
+      autoValidate: options.autoValidate ?? true,
+      notifyOnError: options.notifyOnError ?? true,
+      debounceMs: options.debounceMs ?? 500
+    };
+  }
+  /**
+   * Start watching schema files
+   */
+  async start() {
+    this.logger.info(chalk.cyan("\u{1F50D} Starting schema watcher..."));
+    this.logger.info(chalk.dim(`  Watching: ${this.options.patterns.join(", ")}`));
+    this.watcher = watch(this.options.patterns, {
+      ignored: this.options.ignored,
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.watcher.on("add", (path2) => this.handleFileEvent("add", path2)).on("change", (path2) => this.handleFileEvent("change", path2)).on("unlink", (path2) => this.handleFileEvent("unlink", path2)).on("error", (error) => this.handleError(error));
+    if (this.options.autoValidate) {
+      loadRiskDetectorModule().catch(() => {
+      });
+    }
+    this.logger.success("\u2705 Schema watcher started");
+    this.logger.info(chalk.dim("  Press Ctrl+C to stop\n"));
+  }
+  /**
+   * Stop watching
+   */
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+      this.logger.info("Schema watcher stopped");
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+  /**
+   * Handle file system events with debouncing
+   */
+  handleFileEvent(type, path2) {
+    const existingTimer = this.debounceTimers.get(path2);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      this.processFileEvent({ type, path: path2, timestamp: /* @__PURE__ */ new Date() });
+      this.debounceTimers.delete(path2);
+    }, this.options.debounceMs);
+    this.debounceTimers.set(path2, timer);
+  }
+  /**
+   * Process file system event
+   */
+  async processFileEvent(event) {
+    const { type, path: path2 } = event;
+    const fileName = basename(path2);
+    switch (type) {
+      case "add":
+        this.logger.info(chalk.green(`\u2795 Added: ${fileName}`));
+        break;
+      case "change":
+        this.logger.info(chalk.blue(`\u{1F4DD} Changed: ${fileName}`));
+        break;
+      case "unlink":
+        this.logger.info(chalk.red(`\u{1F5D1}\uFE0F  Removed: ${fileName}`));
+        return;
+    }
+    if (this.options.autoValidate) {
+      await this.validateFile(path2);
+    }
+  }
+  /**
+   * Validate schema file
+   */
+  async validateFile(path2) {
+    try {
+      this.logger.info(chalk.dim("  Validating..."));
+      const validationResult = await validateSchemaFile(path2);
+      if (validationResult.isValid) {
+        this.logger.success(chalk.green("  \u2713 Validation passed"));
+        const { detectSchemaRisks } = await loadRiskDetectorModule();
+        const risks = await detectSchemaRisks(path2);
+        if (risks.length > 0) {
+          this.logger.warn(`  \u26A0\uFE0F  ${risks.length} risk(s) detected`);
+          for (const risk of risks) {
+            this.logger.warn(chalk.yellow(`    \u2022 ${risk.description}`));
+          }
+        }
+      } else {
+        this.logger.error(chalk.red("  \u2717 Validation failed"));
+        for (const error of validationResult.errors) {
+          this.logger.error(chalk.red(`    \u2022 ${error}`));
+        }
+        if (this.options.notifyOnError) {
+          await notifyDesktop({
+            title: "Schema Validation Failed",
+            message: `${validationResult.errors.length} error(s) in ${path2.split("/").pop()}`,
+            type: "error"
+          });
+        }
+      }
+    } catch (error) {
+      this.logger.error(chalk.red(`  Error during validation: ${error}`));
+    }
+    this.logger.info("");
+  }
+  /**
+   * Handle watcher errors
+   */
+  handleError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    this.logger.error(chalk.red(`Watcher error: ${message}`));
+  }
+  /**
+   * Get watcher statistics
+   */
+  getStats() {
+    return {
+      isActive: this.watcher !== null,
+      watchedFiles: this.watcher?.getWatched() ? Object.keys(this.watcher.getWatched()).length : 0
+    };
+  }
+};
+async function createSchemaWatcher(options) {
+  const watcher = new SchemaWatcher(options);
+  await watcher.start();
+  return watcher;
+}
+
+// src/watchers/test-watcher.ts
+init_esm_shims();
+
+// src/incremental/affected-tests.ts
+init_esm_shims();
+function isVitestV1Output(output) {
+  if (typeof output !== "object" || output === null) return false;
+  const obj = output;
+  return Array.isArray(obj.testResults);
+}
+function isVitestV2Output(output) {
+  if (typeof output !== "object" || output === null) return false;
+  const obj = output;
+  return Array.isArray(obj.results);
+}
+function parseVitestV1(output) {
+  let passed = 0;
+  let failed = 0;
+  let total = 0;
+  for (const file of output.testResults || []) {
+    for (const assertion of file.assertionResults || []) {
+      total++;
+      if (assertion.status === "passed") passed++;
+      else if (assertion.status === "failed") failed++;
+    }
+  }
+  return { passed, failed, total };
+}
+function parseVitestV2(output) {
+  let passed = 0;
+  let failed = 0;
+  let total = 0;
+  for (const file of output.results || []) {
+    for (const test of file.tests || []) {
+      total++;
+      const state = test.result?.state;
+      if (state === "pass") passed++;
+      else if (state === "fail") failed++;
+    }
+  }
+  return { passed, failed, total };
+}
+function parseVitestOutput(jsonOutput) {
+  if (isVitestV1Output(jsonOutput)) {
+    return parseVitestV1(jsonOutput);
+  }
+  if (isVitestV2Output(jsonOutput)) {
+    return parseVitestV2(jsonOutput);
+  }
+  return { passed: 0, failed: 0, total: 0 };
+}
+async function findAffectedTests(changedFiles) {
+  const affectedTests = /* @__PURE__ */ new Set();
+  for (const file of changedFiles) {
+    if (file.includes(".test.") || file.includes(".spec.")) {
+      affectedTests.add(file);
+      continue;
+    }
+    const relatedTests = await findRelatedTestFiles(file);
+    for (const test of relatedTests) {
+      affectedTests.add(test);
+    }
+  }
+  return Array.from(affectedTests);
+}
+async function findRelatedTestFiles(sourceFile) {
+  const tests = [];
+  try {
+    const baseName = sourceFile.replace(/\.(ts|tsx|js|jsx)$/, "");
+    const fileName = baseName.split("/").pop() || "";
+    const patterns = [
+      `**/${fileName}.test.ts`,
+      `**/${fileName}.test.tsx`,
+      `**/${fileName}.spec.ts`,
+      `**/${fileName}.spec.tsx`,
+      `**/__tests__/${fileName}.ts`,
+      `**/__tests__/${fileName}.tsx`
+    ];
+    for (const pattern of patterns) {
+      const matches = await glob(pattern, {
+        ignore: ["**/node_modules/**", "**/dist/**"]
+      });
+      tests.push(...matches);
+    }
+    return tests;
+  } catch (_error) {
+    return tests;
+  }
+}
+async function runAffectedTests(changedFiles) {
+  const affectedTests = await findAffectedTests(changedFiles);
+  if (affectedTests.length === 0) {
+    return {
+      success: true,
+      totalTests: 0,
+      passedTests: 0,
+      failedTests: 0,
+      duration: 0
+    };
+  }
+  const startTime = Date.now();
+  try {
+    const result = await execa(
+      "pnpm",
+      ["exec", "vitest", "run", "--reporter=json", ...affectedTests],
+      {
+        reject: false,
+        // Don't throw on test failures
+        timeout: 3e5
+        // 5 minute timeout
+      }
+    );
+    const duration = Date.now() - startTime;
+    try {
+      const jsonOutput = JSON.parse(result.stdout);
+      const { passed, failed, total } = parseVitestOutput(jsonOutput);
+      if (total === 0 && affectedTests.length > 0) {
+        process.stderr.write(
+          "[affected-tests] Warning: Unrecognized vitest output format, falling back to exit code\n"
+        );
+        return {
+          success: result.exitCode === 0,
+          totalTests: affectedTests.length,
+          passedTests: result.exitCode === 0 ? affectedTests.length : 0,
+          failedTests: result.exitCode === 0 ? 0 : affectedTests.length,
+          duration
+        };
+      }
+      return {
+        success: failed === 0,
+        totalTests: total,
+        passedTests: passed,
+        failedTests: failed,
+        duration
+      };
+    } catch {
+      return {
+        success: result.exitCode === 0,
+        totalTests: affectedTests.length,
+        passedTests: result.exitCode === 0 ? affectedTests.length : 0,
+        failedTests: result.exitCode === 0 ? 0 : affectedTests.length,
+        duration
+      };
+    }
+  } catch (error) {
+    const duration = Date.now() - startTime;
+    const message = error instanceof Error ? error.message : String(error);
+    process.stderr.write(`[affected-tests] Test execution failed: ${message}
+`);
+    return {
+      success: false,
+      totalTests: affectedTests.length,
+      passedTests: 0,
+      failedTests: affectedTests.length,
+      duration
+    };
+  }
+}
+
+// src/watchers/test-watcher.ts
+var TestWatcher = class {
+  watcher = null;
+  logger = createCLILogger("test-watcher");
+  debounceTimers = /* @__PURE__ */ new Map();
+  options;
+  isRunning = false;
+  constructor(options) {
+    this.options = {
+      patterns: options.patterns,
+      ignored: options.ignored || ["**/node_modules/**", "**/.git/**", "**/dist/**"],
+      autoRun: options.autoRun ?? true,
+      notifyOnFailure: options.notifyOnFailure ?? true,
+      debounceMs: options.debounceMs ?? 1e3
+    };
+  }
+  /**
+   * Start watching test files
+   */
+  async start() {
+    this.logger.info(chalk.cyan("\u{1F50D} Starting test watcher..."));
+    this.logger.info(chalk.dim(`  Watching: ${this.options.patterns.join(", ")}`));
+    this.watcher = watch(this.options.patterns, {
+      ignored: this.options.ignored,
+      persistent: true,
+      ignoreInitial: true
+    });
+    this.watcher.on("add", (path2) => this.handleFileEvent("add", path2)).on("change", (path2) => this.handleFileEvent("change", path2)).on("unlink", (path2) => this.handleFileEvent("unlink", path2)).on("error", (error) => this.handleError(error));
+    this.logger.success("\u2705 Test watcher started");
+    this.logger.info(chalk.dim("  Press Ctrl+C to stop\n"));
+  }
+  /**
+   * Stop watching
+   */
+  async stop() {
+    if (this.watcher) {
+      await this.watcher.close();
+      this.watcher = null;
+      this.logger.info("Test watcher stopped");
+    }
+    for (const timer of this.debounceTimers.values()) {
+      clearTimeout(timer);
+    }
+    this.debounceTimers.clear();
+  }
+  /**
+   * Handle file system events with debouncing
+   */
+  handleFileEvent(type, path2) {
+    const existingTimer = this.debounceTimers.get(path2);
+    if (existingTimer) {
+      clearTimeout(existingTimer);
+    }
+    const timer = setTimeout(() => {
+      this.processFileEvent(type, path2);
+      this.debounceTimers.delete(path2);
+    }, this.options.debounceMs);
+    this.debounceTimers.set(path2, timer);
+  }
+  /**
+   * Process file system event
+   */
+  async processFileEvent(type, path2) {
+    if (this.isRunning) {
+      this.logger.warn(chalk.yellow("\u23F3 Tests already running, skipping..."));
+      return;
+    }
+    const fileName = path2.split("/").pop() || path2;
+    switch (type) {
+      case "add":
+        this.logger.info(chalk.green(`\u2795 Test added: ${fileName}`));
+        break;
+      case "change":
+        this.logger.info(chalk.blue(`\u{1F4DD} Test changed: ${fileName}`));
+        break;
+      case "unlink":
+        this.logger.info(chalk.red(`\u{1F5D1}\uFE0F  Test removed: ${fileName}`));
+        return;
+    }
+    if (this.options.autoRun) {
+      await this.runTests(path2);
+    }
+  }
+  /**
+   * Run affected tests
+   */
+  async runTests(changedFile) {
+    this.isRunning = true;
+    try {
+      this.logger.info(chalk.cyan("\n\u{1F9EA} Running affected tests...\n"));
+      const startTime = Date.now();
+      const result = await runAffectedTests([changedFile]);
+      const duration = Date.now() - startTime;
+      if (result.success) {
+        this.logger.success(
+          chalk.green(
+            `
+\u2705 Tests passed (${result.passedTests}/${result.totalTests}) in ${duration}ms`
+          )
+        );
+        await notifyDesktop({
+          title: "Tests Passed",
+          message: `${result.passedTests}/${result.totalTests} tests passed`,
+          type: "success"
+        });
+      } else {
+        this.logger.error(
+          chalk.red(`
+\u274C Tests failed (${result.failedTests} failed) in ${duration}ms`)
+        );
+        if (this.options.notifyOnFailure) {
+          await notifyDesktop({
+            title: "Tests Failed",
+            message: `${result.failedTests} test(s) failed`,
+            type: "error"
+          });
+        }
+      }
+    } catch (error) {
+      this.logger.error(chalk.red(`Test execution error: ${error}`));
+    } finally {
+      this.isRunning = false;
+      this.logger.info("");
+    }
+  }
+  /**
+   * Handle watcher errors
+   */
+  handleError(error) {
+    const message = error instanceof Error ? error.message : String(error);
+    this.logger.error(chalk.red(`Watcher error: ${message}`));
+  }
+  /**
+   * Get watcher status
+   */
+  getStatus() {
+    return {
+      isActive: this.watcher !== null,
+      isRunning: this.isRunning
+    };
+  }
+};
+async function createTestWatcher(options) {
+  const watcher = new TestWatcher(options);
+  await watcher.start();
+  return watcher;
+}
+
+// src/commands/watch.ts
+var logger2 = createCLILogger("watch");
+function addFallbackSchemaPatterns(patterns) {
+  const detected = detectDatabasePackage(process.cwd());
+  if (detected) {
+    patterns.push(path.join(detected, "src/schema/**/*.ts"));
+    patterns.push(path.join(detected, "sql/**/*.sql"));
+    return;
+  }
+  for (const candidate of DATABASE_PACKAGE_CANDIDATES) {
+    patterns.push(`packages/${candidate}/src/schema/**/*.ts`);
+    patterns.push(`packages/${candidate}/sql/**/*.sql`);
+  }
+  patterns.push("src/schema/**/*.ts");
+  patterns.push("db/src/schema/**/*.ts");
+}
+async function buildSchemaPatterns() {
+  const patterns = ["supabase/schemas/**/*.sql"];
+  try {
+    const dbPackagePath = await getDatabasePackagePath();
+    patterns.push(path.join(dbPackagePath, "src/schema/**/*.ts"));
+    patterns.push(path.join(dbPackagePath, "sql/**/*.sql"));
+  } catch {
+    addFallbackSchemaPatterns(patterns);
+  }
+  return patterns;
+}
+var watchSchemaCommand = new Command("schema").description("Watch schema files for changes").option("--no-validate", "Disable automatic validation").option("--no-notify", "Disable desktop notifications").action(async (options) => {
+  try {
+    if (isNonInteractiveEnabled()) {
+      throw new CLIError(
+        "Watch mode is not available in non-interactive mode",
+        "NON_INTERACTIVE_REQUIRED",
+        ["Run without --json/--format json", "Avoid running in CI"]
+      );
+    }
+    assertTtyRequired("watch schema");
+    logger2.section("Schema Watcher");
+    const patterns = await buildSchemaPatterns();
+    const watcher = await createSchemaWatcher({
+      patterns,
+      autoValidate: options.validate ?? true,
+      notifyOnError: options.notify ?? true
+    });
+    const cleanup = async () => {
+      logger2.info(chalk.yellow("Stopping schema watcher..."));
+      await watcher.stop();
+    };
+    registerCleanup(cleanup);
+    await new Promise(() => {
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Schema watcher failed",
+      "WATCH_SCHEMA_ERROR",
+      ["Check error details above", "Verify file paths are correct"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var watchTestCommand = new Command("test").description("Watch test files and re-run on changes").option("--no-run", "Disable automatic test execution").option("--no-notify", "Disable desktop notifications").action(async (options) => {
+  try {
+    if (isNonInteractiveEnabled()) {
+      throw new CLIError(
+        "Watch mode is not available in non-interactive mode",
+        "NON_INTERACTIVE_REQUIRED",
+        ["Run without --json/--format json", "Avoid running in CI"]
+      );
+    }
+    assertTtyRequired("watch test");
+    logger2.section("Test Watcher");
+    const watcher = await createTestWatcher({
+      patterns: [
+        "packages/**/tests/**/*.test.ts",
+        "packages/**/__tests__/**/*.ts",
+        "apps/**/tests/**/*.test.ts",
+        "apps/**/__tests__/**/*.ts"
+      ],
+      autoRun: options.run ?? true,
+      notifyOnFailure: options.notify ?? true
+    });
+    const cleanup = async () => {
+      logger2.info(chalk.yellow("Stopping test watcher..."));
+      await watcher.stop();
+    };
+    registerCleanup(cleanup);
+    await new Promise(() => {
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Test watcher failed",
+      "WATCH_TEST_ERROR",
+      ["Check error details above", "Verify test file paths are correct"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var watchAllAction = async (options) => {
+  try {
+    if (isNonInteractiveEnabled()) {
+      throw new CLIError(
+        "Watch mode is not available in non-interactive mode",
+        "NON_INTERACTIVE_REQUIRED",
+        ["Run without --json/--format json", "Avoid running in CI"]
+      );
+    }
+    assertTtyRequired("watch --all");
+    logger2.section("Combined Watcher");
+    logger2.info(chalk.cyan("Starting schema and test watchers...\n"));
+    const schemaPatterns = await buildSchemaPatterns();
+    const schemaWatcher = await createSchemaWatcher({
+      patterns: schemaPatterns,
+      autoValidate: options.validate ?? true,
+      notifyOnError: options.notify ?? true
+    });
+    const testWatcher = await createTestWatcher({
+      patterns: [
+        "packages/**/tests/**/*.test.ts",
+        "packages/**/__tests__/**/*.ts",
+        "apps/**/tests/**/*.test.ts",
+        "apps/**/__tests__/**/*.ts"
+      ],
+      autoRun: options.run ?? true,
+      notifyOnFailure: options.notify ?? true
+    });
+    logger2.success(chalk.green("\u2705 All watchers started\n"));
+    const cleanup = async () => {
+      logger2.info(chalk.yellow("Stopping all watchers..."));
+      await Promise.all([schemaWatcher.stop(), testWatcher.stop()]);
+    };
+    registerCleanup(cleanup);
+    await new Promise(() => {
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Combined watcher failed",
+      "WATCH_ALL_ERROR",
+      ["Check error details above", "Verify file paths are correct"],
+      error instanceof Error ? error : void 0
+    );
+  }
+};
+var watchCommand = new Command("watch").description("Watch files for changes and provide instant feedback").option("--all", "Watch all file types (schema + tests)").option("--no-validate", "Disable automatic validation").option("--no-run", "Disable automatic test execution").option("--no-notify", "Disable desktop notifications").action(async (options) => {
+  if (options.all) {
+    await watchAllAction(options);
+  } else {
+    logger2.info("Usage: runa watch [command]");
+    logger2.info("");
+    logger2.info("Commands:");
+    logger2.info("  schema    Watch schema files");
+    logger2.info("  test      Watch test files");
+    logger2.info("");
+    logger2.info("Options:");
+    logger2.info("  --all     Watch all file types");
+  }
+});
+watchCommand.addCommand(watchSchemaCommand);
+watchCommand.addCommand(watchTestCommand);
+
+export { watchCommand, watchSchemaCommand, watchTestCommand };