@runa-ai/runa-cli 0.5.72 → 0.7.0

package/dist/init-ZIL6LRFO.js

@@ -0,0 +1,631 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { diagnoseInitFailure } from './chunk-AAIE4F2U.js';
+import { getVercelRootDirectory } from './chunk-MXRWBNIY.js';
+import { fetchTemplates } from './chunk-SGJG3BKD.js';
+import { syncRunaConfigWithVercel } from './chunk-6AALH2ED.js';
+import './chunk-DRSUEMAK.js';
+import './chunk-RZLYEO4U.js';
+import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
+import './chunk-WJXC4MVY.js';
+import './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import fs from 'fs';
+import path from 'path';
+import { createCLILogger, CLIError, repairRunaConfig, detectExistingInitConfig, initProject, validateInitResult, detectDatabasePackage } from '@runa-ai/runa';
+import { Command } from 'commander';
+import { z } from 'zod';
+
+createRequire(import.meta.url);
+
+// src/commands/init.ts
+init_esm_shims();
+
+// src/utils/help-system.ts
+init_esm_shims();
+var logger = createCLILogger("help");
+var HELP_DATABASE = [
+  // Init command errors
+  {
+    command: "init",
+    errorPattern: /templates directory not found/i,
+    helpText: `
+Templates directory not found. This usually means:
+  \u2022 @runa-ai/runa is not installed correctly
+  \u2022 You're running from the wrong directory
+
+Fix:
+  1. Verify installation: pnpm list @runa-ai/runa
+  2. Reinstall if needed: pnpm add -D @runa-ai/runa
+  3. Run from project root (where package.json exists)
+    `,
+    relatedCommands: ["runa check", "runa status"]
+  },
+  {
+    command: "init",
+    errorPattern: /package\.json/i,
+    helpText: `
+Not in a valid Node.js project directory.
+
+Fix:
+  1. Navigate to your project root directory
+  2. Ensure package.json exists
+  3. If this is a new project: pnpm init
+    `,
+    relatedCommands: ["runa check"]
+  },
+  // Database connection errors
+  {
+    command: "db:sync",
+    errorPattern: /DATABASE_URL.*not.*set/i,
+    helpText: `
+DATABASE_URL environment variable is not set.
+
+For local development:
+  1. Start Supabase: runa db start
+  2. Get connection string: supabase status
+  3. Set in .env.development: DATABASE_URL=postgresql://postgres:postgres@localhost:54322/postgres
+    `,
+    relatedCommands: ["runa db start", "runa status"]
+  },
+  {
+    command: "db:sync",
+    errorPattern: /connection.*refused|ECONNREFUSED/i,
+    helpText: `
+Cannot connect to database. The database server is not running or not accessible.
+
+Fix:
+  1. Start local Supabase: runa db start
+  2. Check if Supabase is running: supabase status
+  3. Verify DATABASE_URL points to the correct host/port
+  4. Check firewall settings if using remote database
+    `,
+    relatedCommands: ["runa db start", "supabase status"]
+  },
+  // Schema errors
+  {
+    command: "db:sync",
+    errorPattern: /syntax error|invalid syntax/i,
+    helpText: `
+SQL syntax error in your schema or migrations.
+
+Fix:
+  1. Check your schema files (see runa.config.ts for schema path)
+  2. Review recent changes to schema definitions
+  3. Validate Drizzle syntax: pnpm type-check
+  4. Check SQL functions in database package sql/ directory
+    `,
+    relatedCommands: ["pnpm type-check"]
+  },
+  {
+    command: "db:sync",
+    errorPattern: /constraint.*violation|foreign key/i,
+    helpText: `
+Database constraint violation. This usually happens when:
+  \u2022 Trying to add a foreign key to non-existent data
+  \u2022 Adding NOT NULL constraint to column with existing NULL values
+  \u2022 Unique constraint violation
+
+Fix:
+  1. Check existing data: Connect to DB and query affected tables
+  2. Consider data migration: Write a seed script to fix existing data
+  3. Make constraint nullable temporarily: Add .nullable() to column
+  4. Review schema changes (see runa.config.ts for schema path)
+    `,
+    relatedCommands: ["runa db start", "supabase db reset"]
+  },
+  // Docker/Supabase errors
+  {
+    command: "db:start",
+    errorPattern: /docker.*not.*running|cannot connect to docker/i,
+    helpText: `
+Docker is not running or not installed.
+
+Fix:
+  1. Start Colima: colima start --cpu 4 --memory 8 --vm-type vz --mount-type virtiofs
+  2. Install Colima: brew install colima docker
+  3. Linux: sudo systemctl start docker
+  4. Verify Docker is running: docker ps
+    `,
+    relatedCommands: ["runa check"]
+  },
+  {
+    command: "db:start",
+    errorPattern: /port.*already.*allocated|address already in use/i,
+    helpText: `
+Required port is already in use by another process.
+
+Fix:
+  1. Find process using the port: lsof -i :54322
+  2. Stop the conflicting process
+  3. Or stop existing Supabase instance: supabase stop
+  4. Clean up Docker containers: docker ps -a
+    `,
+    relatedCommands: ["supabase stop", "runa check"]
+  },
+  // Test errors
+  {
+    command: "test",
+    errorPattern: /no test files found/i,
+    helpText: `
+No test files found in the project.
+
+Fix:
+  1. Check test file naming: *.test.ts or *.spec.ts
+  2. Verify test files are in correct location (tests/ or __tests__/)
+  3. Generate tests: runa test:gen
+  4. Check Vitest configuration: vitest.config.ts
+    `,
+    relatedCommands: ["runa test:gen"]
+  },
+  {
+    command: "test",
+    errorPattern: /test environment.*not.*ready/i,
+    helpText: `
+Test environment is not properly set up.
+
+Fix:
+  1. Start database: runa db start
+  2. Check environment variables in .env.test
+  3. Run database sync: runa db sync
+  4. Verify test database connection: runa status
+    `,
+    relatedCommands: ["runa db start", "runa status"]
+  }
+];
+function findContextualHelp(command, errorMessage) {
+  return HELP_DATABASE.find((h) => h.command === command && h.errorPattern.test(errorMessage)) || null;
+}
+function getGenericHelp(command) {
+  const genericHelp = {
+    init: `
+runa init - Initialize project with runa configuration
+
+Common issues:
+  \u2022 Not in project root directory
+  \u2022 @runa-ai/runa not installed
+  \u2022 Missing package.json
+
+Try:
+  \u2022 runa check (check environment)
+  \u2022 runa status (check configuration)
+    `,
+    "db:start": `
+runa db start - Start local Supabase
+
+Common issues:
+  \u2022 Docker not running
+  \u2022 Ports already in use
+  \u2022 Missing supabase/config.toml
+
+Try:
+  \u2022 Check Docker: docker ps
+  \u2022 Check ports: lsof -i :54322
+  \u2022 runa check (full environment check)
+    `,
+    "db:sync": `
+runa db sync - Sync database schema (Ephemeral Migration)
+
+Common issues:
+  \u2022 DATABASE_URL not set
+  \u2022 Database not running
+  \u2022 Schema syntax errors
+
+Try:
+  \u2022 Start database: runa db start
+  \u2022 Check connection: supabase status
+  \u2022 Validate schema: pnpm type-check
+    `,
+    test: `
+runa test - Run tests
+
+Common issues:
+  \u2022 No test files found
+  \u2022 Test environment not ready
+  \u2022 Database connection issues
+
+Try:
+  \u2022 Generate tests: runa test:gen
+  \u2022 Start database: runa db start
+  \u2022 Check status: runa status
+    `
+  };
+  return genericHelp[command];
+}
+function displayHelp(help) {
+  logger.info(help.helpText);
+  if (help.relatedCommands && help.relatedCommands.length > 0) {
+    logger.info("\n\u{1F517} Related commands:");
+    for (const cmd of help.relatedCommands) {
+      logger.info(`   ${cmd}`);
+    }
+  }
+  if (help.learnMoreUrl) {
+    logger.info(`
+\u{1F4D6} Learn more: ${help.learnMoreUrl}`);
+  }
+}
+
+// src/commands/init.ts
+function checkZodVersion() {
+  const zodPaths = [
+    path.join(process.cwd(), "node_modules", "zod", "package.json"),
+    // Check home directory node_modules (common source of conflicts)
+    path.join(process.env.HOME ?? "", "node_modules", "zod", "package.json")
+  ];
+  for (const zodPath of zodPaths) {
+    if (!fs.existsSync(zodPath)) continue;
+    try {
+      const raw = fs.readFileSync(zodPath, "utf-8");
+      const pkg = JSON.parse(raw);
+      const version = pkg.version ?? "";
+      if (version.startsWith("3.")) {
+        throw new CLIError(
+          `Incompatible zod version detected: ${version}`,
+          "ZOD_VERSION_INCOMPATIBLE",
+          [
+            "runa SDK requires zod v4.x, but found zod v3.x",
+            `Conflicting zod found at: ${path.dirname(zodPath)}`,
+            "",
+            "Solutions:",
+            "1. Run from a clean project directory without existing node_modules",
+            "2. Remove conflicting zod: rm -rf ~/node_modules (if in home dir)",
+            "3. Or create a new directory and run: pnpm dlx @runa-ai/runa-cli init"
+          ]
+        );
+      }
+    } catch (error) {
+      if (error instanceof CLIError) throw error;
+    }
+  }
+}
+var InitSuccessDataSchema = z.object({
+  projectName: z.string(),
+  copiedCount: z.number().int().nonnegative(),
+  skippedCount: z.number().int().nonnegative(),
+  huskyInstalled: z.boolean(),
+  dependenciesInstalled: z.boolean(),
+  isMonorepo: z.boolean(),
+  /** Database platform (not ORM). Drizzle is always the ORM. */
+  dbType: z.literal("supabase"),
+  existingConfig: z.object({
+    hasConfig: z.boolean(),
+    files: z.array(z.string())
+  }),
+  /** mise setup result (if setupMise was true) */
+  miseSetup: z.object({
+    miseInstalled: z.boolean(),
+    miseTrusted: z.boolean(),
+    miseToolsInstalled: z.boolean(),
+    preflightPassed: z.boolean()
+  }).optional(),
+  /** Vercel sync result (if not skipped) */
+  vercelSync: z.object({
+    detected: z.boolean(),
+    rootDirectory: z.string().nullable(),
+    configUpdated: z.boolean(),
+    reason: z.string().optional()
+  }).optional()
+}).strict();
+function renderExistingConfigNotice(params) {
+  if (!params.existingConfig.hasConfig || params.force) return;
+  params.logger.warn("Existing runa configuration detected");
+  params.logger.info("Found:");
+  for (const file of params.existingConfig.files) {
+    params.logger.info(`  \u2022 ${file}`);
+  }
+  params.logger.info("Non-interactive mode: keeping existing files by default.");
+  params.logger.info("To overwrite existing files, re-run with: runa init --force");
+}
+function renderInstallStatus(logger2, success, successMsg, failMsg, manualCmd) {
+  if (success) {
+    logger2.success(successMsg);
+    return;
+  }
+  logger2.warn(failMsg);
+  logger2.info(manualCmd);
+}
+function renderMiseSetupStatus(params) {
+  const miseSetup = params.result.miseSetup;
+  if (!miseSetup) {
+    return;
+  }
+  params.logger.info("");
+  params.logger.section("mise Setup");
+  if (!miseSetup.miseInstalled) {
+    params.logger.warn("mise is not installed");
+    params.logger.info("");
+    params.logger.info(
+      "mise is a tool version manager that installs node, pnpm, supabase, and more."
+    );
+    params.logger.info("");
+    params.logger.info("To install mise:");
+    params.logger.info("  curl https://mise.run | sh");
+    params.logger.info(`  echo 'eval "$(mise activate zsh)"' >> ~/.zshrc`);
+    params.logger.info("  source ~/.zshrc");
+    params.logger.info("");
+    params.logger.info("Then run setup:");
+    params.logger.info("  mise trust && mise install && mise run setup");
+    return;
+  }
+  params.logger.success("\u2705 mise installed");
+  if (miseSetup.miseTrusted) {
+    params.logger.success("\u2705 mise.toml trusted");
+  } else {
+    params.logger.warn("\u26A0\uFE0F  mise.toml not trusted");
+    params.logger.info("   Run: mise trust");
+  }
+  if (miseSetup.miseToolsInstalled) {
+    params.logger.success("\u2705 Tools installed (node, pnpm, go, supabase, gh)");
+  } else {
+    params.logger.warn("\u26A0\uFE0F  Tools not installed");
+    params.logger.info("   Run: mise install");
+  }
+  if (miseSetup.preflightPassed) {
+    params.logger.success("\u2705 Preflight checks passed");
+  } else {
+    params.logger.warn("\u26A0\uFE0F  Preflight checks failed");
+    params.logger.info("   Check: Docker running, gh auth, NODE_AUTH_TOKEN");
+    params.logger.info("   Run: mise run preflight (for details)");
+  }
+}
+async function syncWithVercelProject(targetDir, logger2) {
+  logger2.info("");
+  logger2.section("Vercel Project Sync");
+  const rootDirectory = await getVercelRootDirectory();
+  if (!rootDirectory) {
+    logger2.info("No Vercel project linked (skipping auto-config)");
+    logger2.info("Tip: Run `vercel link` to link a project");
+    return {
+      detected: false,
+      rootDirectory: null,
+      configUpdated: false,
+      reason: "No Vercel project linked"
+    };
+  }
+  logger2.info(`Detected Vercel Root Directory: ${rootDirectory}`);
+  const syncResult = syncRunaConfigWithVercel(targetDir, rootDirectory);
+  if (!syncResult) {
+    return {
+      detected: true,
+      rootDirectory,
+      configUpdated: false,
+      reason: "Sync not needed"
+    };
+  }
+  if (syncResult.updated) {
+    logger2.success(`\u2705 Updated runa.config.ts: ${syncResult.field} = '${rootDirectory}'`);
+    return {
+      detected: true,
+      rootDirectory,
+      configUpdated: true,
+      reason: syncResult.reason
+    };
+  }
+  logger2.info(`runa.config.ts: ${syncResult.reason}`);
+  return {
+    detected: true,
+    rootDirectory,
+    configUpdated: false,
+    reason: syncResult.reason
+  };
+}
+function renderNextSteps(params) {
+  params.logger.info("");
+  params.logger.section("Next Steps");
+  const dbPackage = detectDatabasePackage(process.cwd()) ?? "packages/database";
+  if (params.result.dbType === "supabase") {
+    const syncCmd = params.result.isMonorepo ? `cd ${dbPackage} && runa db sync` : "runa db sync";
+    params.logger.info("1. Start local Supabase:");
+    params.logger.info("   supabase start");
+    params.logger.info("");
+    params.logger.info("2. Apply schema (REQUIRED):");
+    params.logger.info(`   ${syncCmd}`);
+    params.logger.info("   \u26A0\uFE0F  This generates TypeScript types. Skip = type errors.");
+    params.logger.info("");
+    params.logger.info("3. Start developing:");
+    params.logger.info("   pnpm dev");
+  } else {
+    params.logger.info("1. Start developing:");
+    params.logger.info("   pnpm dev");
+  }
+  params.logger.info("");
+  params.logger.info("\u{1F4A1} Troubleshooting:");
+  params.logger.info("   runa check           # Diagnose environment issues");
+  params.logger.info("   runa check --verbose # Detailed output with fix hints");
+  params.logger.info("");
+  params.logger.info(`\u{1F4D6} Documentation: ${dbPackage}/SETUP-AFTER-INIT.md`);
+}
+function tryShowContextualHelp(params) {
+  const help = findContextualHelp("init", params.message);
+  if (!help) return false;
+  displayHelp(help);
+  params.suggestions.push("Review contextual help above");
+  return true;
+}
+function applyDiagnostics(params) {
+  const diagnostics = diagnoseInitFailure(params.message);
+  if (diagnostics.length === 0) return false;
+  params.logger.info("\n\u{1F50D} Diagnostics:");
+  for (const diagnostic of diagnostics) {
+    params.logger.warn(`  \u2022 ${diagnostic.message}`);
+    if (!diagnostic.fixInstructions) continue;
+    params.logger.info("\n  Fix:");
+    for (const instruction of diagnostic.fixInstructions) {
+      params.logger.info(`    - ${instruction}`);
+      params.suggestions.push(instruction);
+    }
+  }
+  return true;
+}
+function showGenericInitHelp(params) {
+  const genericHelp = getGenericHelp("init");
+  params.logger.info(`
+${genericHelp}`);
+  params.suggestions.push("Review generic help above");
+}
+function toInitCliError(params) {
+  const suggestions = [];
+  if (!(params.error instanceof Error)) {
+    return new CLIError(
+      "Initialization failed with unknown error",
+      "INIT_UNKNOWN_ERROR",
+      ["Check error details above", "Try: runa check"],
+      params.error instanceof Error ? params.error : void 0
+    );
+  }
+  const message = params.error.message;
+  const shownContext = tryShowContextualHelp({ message, suggestions });
+  if (!shownContext) {
+    const usedDiagnostics = applyDiagnostics({ logger: params.logger, message, suggestions });
+    if (!usedDiagnostics) {
+      showGenericInitHelp({ logger: params.logger, suggestions });
+    }
+  }
+  suggestions.push("For more help: runa check");
+  return new CLIError(
+    `Initialization failed: ${message}`,
+    "INIT_FAILED",
+    suggestions,
+    params.error
+  );
+}
+function handleRepairConfigMode(options, logger2) {
+  if (!options.repairConfig) {
+    return false;
+  }
+  logger2.section("Repairing runa.config.ts");
+  const projectName = path.basename(process.cwd());
+  const repairResult = repairRunaConfig(process.cwd(), projectName);
+  if (!repairResult.success) {
+    throw new CLIError(`Config repair failed: ${repairResult.message}`, "CONFIG_REPAIR_FAILED", [
+      "The config file could not be repaired automatically",
+      "Try: Remove runa.config.ts and run `runa init` fresh",
+      "Or: Manually fix the config file syntax"
+    ]);
+  }
+  logger2.success("\u2705 Config file repaired successfully");
+  if (repairResult.backupPath) {
+    logger2.info(`   Backup saved to: ${repairResult.backupPath}`);
+  }
+  logger2.info("");
+  logger2.info("Extracted values:");
+  if (repairResult.extractedValues.projectName) {
+    logger2.info(`   projectName: ${repairResult.extractedValues.projectName}`);
+  }
+  if (repairResult.extractedValues.monorepo !== void 0) {
+    logger2.info(`   monorepo: ${repairResult.extractedValues.monorepo}`);
+  }
+  if (repairResult.extractedValues.appDirectory) {
+    logger2.info(`   appDirectory: ${repairResult.extractedValues.appDirectory}`);
+  }
+  logger2.info("");
+  logger2.info("Next steps:");
+  logger2.info("   1. Run `runa check` to verify the configuration");
+  logger2.info("   2. Review the generated runa.config.ts");
+  return true;
+}
+async function runInitWorkflow(options, logger2) {
+  logger2.section("Initializing runa Configuration");
+  checkZodVersion();
+  logger2.step("Fetching templates", 0);
+  const templateResult = await fetchTemplates({
+    version: options.templatesVersion,
+    fresh: options.fresh,
+    verbose: process.env.DEBUG === "true"
+  });
+  logger2.info(
+    templateResult.cached ? `Using ${templateResult.version === "workspace" ? "workspace" : "cached"} templates v${templateResult.version}` : `Fetched templates v${templateResult.version}`
+  );
+  const existingConfig = detectExistingInitConfig(process.cwd());
+  renderExistingConfigNotice({
+    logger: logger2,
+    existingConfig,
+    force: options.force === true
+  });
+  const projectName = path.basename(process.cwd());
+  logger2.info(`Project: ${projectName}`);
+  logger2.step("Applying templates (SDK)", 1);
+  const result = await initProject({
+    targetDir: process.cwd(),
+    projectName,
+    force: options.force === true,
+    installHusky: true,
+    db: options.db,
+    scope: options.scope,
+    setupMise: options.skipMise !== true,
+    skipPostInit: options.skipPostInit === true,
+    templatesDir: templateResult.templatesDir
+  });
+  logger2.info(`Copied ${result.copiedCount} file(s), skipped ${result.skippedCount} file(s)`);
+  if (result.skippedCount > 0 && !options.force) {
+    logger2.info("Use --force to overwrite existing files");
+  }
+  renderInstallStatus(
+    logger2,
+    result.dependenciesInstalled,
+    "Dependencies installed successfully",
+    "Failed to install dependencies",
+    "Run manually: pnpm install"
+  );
+  renderInstallStatus(
+    logger2,
+    result.huskyInstalled,
+    "Git hooks installed successfully",
+    "Failed to install Git hooks (husky)",
+    "You can install manually later: npx husky install"
+  );
+  renderMiseSetupStatus({ logger: logger2, result });
+  let vercelSyncResult;
+  if (options.skipVercel !== true) {
+    vercelSyncResult = await syncWithVercelProject(process.cwd(), logger2);
+  }
+  logger2.info("");
+  logger2.section("Validating Setup");
+  const validation = validateInitResult(process.cwd());
+  if (validation.valid) {
+    logger2.success("\u2705 monorepo: true");
+    logger2.success("\u2705 packages/database/ created");
+    logger2.success("\u2705 Database commands ready");
+  } else {
+    for (const error of validation.errors) {
+      logger2.error(`\u274C ${error}`);
+    }
+  }
+  for (const warning of validation.warnings) {
+    logger2.warn(`\u26A0\uFE0F  ${warning}`);
+  }
+  logger2.info("");
+  logger2.success("Initialization complete!");
+  renderNextSteps({ logger: logger2, result });
+  return { result, vercelSyncResult };
+}
+var initCommand = new Command("init").description("Initialize pj-repo with runa configuration").option("-f, --force", "Overwrite existing files").option("-y, --yes", "Skip all prompts (use defaults)").option("--db <type>", "Database platform (auto|supabase)", "auto").option("--scope <scope>", "Override npm scope for database package (e.g., @company)").option("--skip-mise", "Skip mise setup after init").option("--skip-post-init", "Skip all post-init steps (pnpm install, husky, mise)").option("--skip-vercel", "Skip Vercel project detection and config sync").option("--templates-version <version>", "Override templates version").option("--fresh", "Clear templates cache before fetching").option(
+  "--repair-config",
+  "Repair broken runa.config.ts (extracts existing values and regenerates)"
+).action(async (options) => {
+  const logger2 = createCLILogger("init");
+  try {
+    if (handleRepairConfigMode(options, logger2)) return;
+    const { result, vercelSyncResult } = await runInitWorkflow(options, logger2);
+    emitJsonSuccess(initCommand, InitSuccessDataSchema, {
+      projectName: result.projectName,
+      copiedCount: result.copiedCount,
+      skippedCount: result.skippedCount,
+      huskyInstalled: result.huskyInstalled,
+      dependenciesInstalled: result.dependenciesInstalled,
+      isMonorepo: result.isMonorepo,
+      dbType: result.dbType,
+      existingConfig: result.existingConfig,
+      miseSetup: result.miseSetup,
+      vercelSync: vercelSyncResult
+    });
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw toInitCliError({ error, logger: logger2 });
+  }
+});
+
+export { initCommand };

package/dist/inject-test-attrs-P44BVTQS.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { DEFAULT_INCLUDE_PATTERNS, DEFAULT_EXCLUDE_PATTERNS, injectTestAttrsAction } from './chunk-Z4Z5DNW4.js';
+export { processFiles } from './chunk-Z4Z5DNW4.js';
+import './chunk-DRSUEMAK.js';
+import './chunk-KE6QJBZG.js';
+import './chunk-WJXC4MVY.js';
+import './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { Command } from 'commander';
+
+createRequire(import.meta.url);
+
+// src/commands/inject-test-attrs/index.ts
+init_esm_shims();
+
+// src/commands/inject-test-attrs/commands/inject-test-attrs.ts
+init_esm_shims();
+var injectTestAttrsCommand = new Command("inject-test-attrs").description("Inject XState test attributes into source files (git-managed)").option("--check", "Check if files need injection without modifying (CI mode)").option("--force", "Force re-injection even if marker exists").option("--verbose", "Show detailed output").option("--include <patterns...>", "Glob patterns to include", [...DEFAULT_INCLUDE_PATTERNS]).option("--exclude <patterns...>", "Glob patterns to exclude", [...DEFAULT_EXCLUDE_PATTERNS]).option("--no-manifest", "Skip E2E selector manifest generation").option("--manifest-dir <dir>", "Output directory for manifest files", ".runa").option("--strict-detect", "Fail when fallback machine detection is used (for deterministic CI)").action(async (rawOptions) => {
+  await injectTestAttrsAction(rawOptions, injectTestAttrsCommand);
+});
+
+export { injectTestAttrsCommand };

package/dist/internal/machines/snapshot-helpers.d.ts

@@ -26,5 +26,11 @@ export declare function isSnapshotComplete(snapshot: SnapshotWithStatus): boolea
  * Extract normalized machine error from snapshot context.
  */
 export declare function getSnapshotError(snapshot: SnapshotWithError): string | null;
+/**
+ * Extract a human-readable error message from an unknown error value.
+ *
+ * Useful in XState machine error handlers where event.error is typed as unknown.
+ */
+export declare function getErrorMessage(error: unknown): string;
 export {};
 //# sourceMappingURL=snapshot-helpers.d.ts.map

package/dist/lib/sql-comment-utils.d.ts

@@ -0,0 +1,25 @@
+/**
+ * AI HINT: Shared SQL Comment Stripping Utilities
+ *
+ * Purpose: Canonical implementation of SQL comment/string stripping.
+ * Used by: partition-validator, schema-detector, sql-table-extractor, sql-parser
+ *
+ * Handles:
+ * - Line comments (-- ...)
+ * - Nested block comments (PostgreSQL supports nested block comments)
+ * - Single-quoted strings with escaped quotes ('')
+ * - Double-quoted identifiers with escaped quotes ("")
+ * - Dollar-quoted strings ($tag$...$tag$)
+ * - PostgreSQL E-string literals (E'...' with backslash escapes)
+ */
+export declare function stripSqlComments(content: string): string;
+/**
+ * Replace content inside dollar-quoted strings with spaces.
+ * This prevents false-positive matches inside PL/pgSQL function bodies.
+ *
+ * Input is already comment-stripped (from stripSqlComments), so we only need to
+ * handle dollar-quoted strings — single/double quotes are already handled by the
+ * regex (they can't span multi-statement patterns).
+ */
+export declare function blankDollarQuotedBodies(content: string): string;
+//# sourceMappingURL=sql-comment-utils.d.ts.map