@runa-ai/runa-cli 0.5.72 → 0.6.0

package/dist/cache-H63JKFYH.js

@@ -0,0 +1,112 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { emitJsonSuccess } from './chunk-UU55OH7P.js';
+import './chunk-RRGQCUKT.js';
+import './chunk-JT5SUTWE.js';
+import './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { cacheClear, CacheClearOutputSchema, cachePrune, CachePruneOutputSchema, cacheStats, CacheStatsOutputSchema, cacheList, CacheListOutputSchema, cacheInvalidate, CacheInvalidateOutputSchema } from '@runa-ai/runa/cache';
+import { createCLILogger, CLIError } from '@runa-ai/runa/cli-runtime';
+import { Command } from 'commander';
+
+createRequire(import.meta.url);
+
+// src/commands/cache.ts
+init_esm_shims();
+var logger = createCLILogger("cache");
+var cacheClearCommand = new Command("clear").description("Clear all caches").option("--namespace <name>", "Clear specific cache namespace").action(async (options) => {
+  try {
+    logger.section("Cache Clearing");
+    const output = await cacheClear({
+      namespace: options.namespace ? String(options.namespace) : void 0
+    });
+    emitJsonSuccess(cacheClearCommand, CacheClearOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to clear cache",
+      "CACHE_CLEAR_ERROR",
+      ["Check cache directory permissions"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cachePruneCommand = new Command("prune").description("Remove expired cache entries").option("--namespace <name>", "Prune specific cache namespace").action(async (options) => {
+  try {
+    logger.section("Cache Pruning");
+    const output = await cachePrune({
+      namespace: options.namespace ? String(options.namespace) : void 0
+    });
+    emitJsonSuccess(cachePruneCommand, CachePruneOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to prune cache",
+      "CACHE_PRUNE_ERROR",
+      ["Check cache directory exists"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cacheStatsCommand = new Command("stats").description("Show cache statistics").option("--namespace <name>", "Show stats for specific namespace").action(async (options) => {
+  try {
+    logger.section("Cache Statistics");
+    const output = await cacheStats({
+      namespace: options.namespace ? String(options.namespace) : void 0
+    });
+    emitJsonSuccess(cacheStatsCommand, CacheStatsOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to get cache stats",
+      "CACHE_STATS_ERROR",
+      ["Check cache directory exists"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cacheListCommand = new Command("list").description("List cache namespaces").action(async () => {
+  try {
+    logger.section("Cache Namespaces");
+    const output = await cacheList({});
+    emitJsonSuccess(cacheListCommand, CacheListOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to list caches",
+      "CACHE_LIST_ERROR",
+      ["Check cache directory exists"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cacheInvalidateCommand = new Command("invalidate").description("Invalidate caches based on file changes").option("--pattern <glob>", "File pattern to watch for changes").action(async (options) => {
+  try {
+    logger.section("Cache Invalidation");
+    const output = await cacheInvalidate({
+      pattern: options.pattern ? String(options.pattern) : void 0
+    });
+    emitJsonSuccess(cacheInvalidateCommand, CacheInvalidateOutputSchema, output);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    throw new CLIError(
+      "Failed to invalidate cache",
+      "CACHE_INVALIDATE_ERROR",
+      ["Check file patterns", "Verify cache exists"],
+      error instanceof Error ? error : void 0
+    );
+  }
+});
+var cacheCommand = new Command("cache").description("Manage CLI cache").addCommand(cacheClearCommand).addCommand(cachePruneCommand).addCommand(cacheStatsCommand).addCommand(cacheListCommand).addCommand(cacheInvalidateCommand);
+
+export { cacheClearCommand, cacheCommand, cacheInvalidateCommand, cacheListCommand, cachePruneCommand, cacheStatsCommand };

package/dist/check-6AB5NGWK.js

@@ -0,0 +1,207 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { loadEnvFiles } from './chunk-MNPMZERI.js';
+import './chunk-JMJP4A47.js';
+import './chunk-DRSUEMAK.js';
+import { emitJsonSuccess } from './chunk-UU55OH7P.js';
+import './chunk-RRGQCUKT.js';
+import './chunk-JT5SUTWE.js';
+import { getOutputFormatFromEnv } from './chunk-HKUWEGUX.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { CLIError, createCLILogger } from '@runa-ai/runa/cli-runtime';
+import { runChecks, RunCheckOutputSchema } from '@runa-ai/runa/check';
+import chalk from 'chalk';
+import { Command } from 'commander';
+
+createRequire(import.meta.url);
+
+// src/commands/check/commands/check.ts
+init_esm_shims();
+function getStatusIcon(status, required) {
+  switch (status) {
+    case "ok":
+      return chalk.green("\u2713");
+    case "skipped":
+      return chalk.dim("\u25CB");
+    case "warning":
+      return chalk.yellow("\u26A0");
+    case "missing":
+    case "invalid":
+    case "not_running":
+      return required ? chalk.red("\u2717") : chalk.yellow("\u26A0");
+    default:
+      return chalk.dim("?");
+  }
+}
+function getStatusColor(status, required) {
+  switch (status) {
+    case "ok":
+      return chalk.green;
+    case "skipped":
+      return chalk.dim;
+    case "warning":
+      return chalk.yellow;
+    case "missing":
+    case "invalid":
+    case "not_running":
+      return required ? chalk.red : chalk.yellow;
+    default:
+      return chalk.dim;
+  }
+}
+function renderCheckDetails(logger, details, verbose) {
+  if (details.error) {
+    logger.info(chalk.red(`     \u2514\u2500 Error: ${details.error}`));
+  }
+  if (details.issue) {
+    logger.info(chalk.yellow(`     \u2514\u2500 Issue: ${details.issue}`));
+  }
+  if (details.expected && details.actual) {
+    logger.info(chalk.dim(`     \u2514\u2500 Expected: ${details.expected}`));
+    logger.info(chalk.dim(`     \u2514\u2500 Actual: ${details.actual}`));
+  }
+  if (details.hint) {
+    logger.info(chalk.cyan(`     \u2514\u2500 Hint: ${details.hint}`));
+  }
+  if (verbose && details.path) {
+    logger.info(chalk.dim(`     \u2514\u2500 Path: ${details.path}`));
+  }
+}
+function renderFixHint(logger, fix) {
+  if (fix.command) {
+    logger.info(chalk.dim(`     \u2514\u2500 Fix: ${fix.command}`));
+  } else if (fix.manual) {
+    logger.info(chalk.dim(`     \u2514\u2500 Manual: ${fix.manual}`));
+  }
+}
+function renderCheckResult(logger, check, verbose) {
+  const icon = getStatusIcon(check.status, check.required);
+  const color = getStatusColor(check.status, check.required);
+  const nameWidth = 30;
+  const name = check.name.padEnd(nameWidth);
+  const message = color(check.message);
+  logger.info(`  ${icon} ${name} ${message}`);
+  const isFailed = check.status !== "ok" && check.status !== "skipped";
+  const showDetails = isFailed || verbose;
+  if (showDetails && check.details) {
+    renderCheckDetails(logger, check.details, verbose);
+  }
+  if ((isFailed || verbose) && check.fix) {
+    renderFixHint(logger, check.fix);
+  }
+}
+function renderCategory(logger, category, verbose) {
+  if (category.checks.length === 0) return;
+  logger.info("");
+  logger.info(chalk.bold(`\u2501\u2501\u2501 ${category.label} \u2501\u2501\u2501`));
+  for (const check of category.checks) {
+    renderCheckResult(logger, check, verbose);
+  }
+}
+function renderSummary(logger, output, fix) {
+  logger.info("");
+  logger.info(chalk.bold("\u2501\u2501\u2501 Summary \u2501\u2501\u2501"));
+  const { summary } = output;
+  const parts = [];
+  if (summary.passed > 0) {
+    parts.push(chalk.green(`${summary.passed} passed`));
+  }
+  if (summary.critical > 0) {
+    parts.push(chalk.red(`${summary.critical} critical`));
+  }
+  if (summary.warning > 0) {
+    parts.push(chalk.yellow(`${summary.warning} warnings`));
+  }
+  if (summary.skipped > 0) {
+    parts.push(chalk.dim(`${summary.skipped} skipped`));
+  }
+  if (fix && summary.fixed > 0) {
+    parts.push(chalk.cyan(`${summary.fixed} fixed`));
+  }
+  logger.info(`  ${parts.join(" | ")}`);
+  if (summary.fixable > 0 && !fix) {
+    logger.info("");
+    logger.info(
+      chalk.yellow(`  ${summary.fixable} issue(s) can be auto-fixed. Run: runa check --fix`)
+    );
+  }
+}
+function renderNextActions(logger, output) {
+  if (output.nextActions.length === 0) return;
+  logger.info("");
+  logger.info(chalk.bold("\u2501\u2501\u2501 Next Actions \u2501\u2501\u2501"));
+  const topActions = output.nextActions.slice(0, 5);
+  for (const action of topActions) {
+    const prefix = action.manual ? chalk.yellow("  Manual:") : chalk.cyan("  Run:");
+    const cmd = action.command || action.action;
+    logger.info(`${prefix} ${cmd}`);
+  }
+  if (output.nextActions.length > 5) {
+    logger.info(chalk.dim(`  ... and ${output.nextActions.length - 5} more`));
+  }
+}
+function renderFinalStatus(logger, output) {
+  logger.info("");
+  if (output.exitCode === 1) {
+    logger.error("Critical issues found. Please fix before proceeding.");
+  } else if (output.summary.warning > 0) {
+    logger.warn("Checks passed with warnings. Operations should work.");
+  } else {
+    logger.success("All checks passed! Ready for operations.");
+  }
+}
+async function runCheckAction(options) {
+  const logger = createCLILogger("check");
+  const isJsonMode = getOutputFormatFromEnv() === "json";
+  loadEnvFiles({ runaEnv: "local", silent: true });
+  if (isJsonMode && options.fix) {
+    throw new CLIError(
+      "--fix is not allowed in --json mode (non-interactive)",
+      "NON_INTERACTIVE_REQUIRED",
+      ["Run without --json to use --fix", "Or apply fixes manually based on JSON output"]
+    );
+  }
+  const output = await runChecks({
+    targetDir: options.cwd || process.cwd(),
+    scope: options.scope || "all",
+    fix: options.fix || false,
+    dryRun: options.dryRun || false,
+    verbose: options.verbose || false
+  });
+  if (isJsonMode) {
+    emitJsonSuccess(checkCommand, RunCheckOutputSchema, output);
+    process.exit(output.exitCode);
+  }
+  logger.section(`Project Health Check (scope: ${options.scope || "all"})`);
+  for (const category of output.categories) {
+    renderCategory(logger, category, options.verbose || false);
+  }
+  renderSummary(logger, output, options.fix || false);
+  if (!output.success) {
+    renderNextActions(logger, output);
+  }
+  renderFinalStatus(logger, output);
+  process.exitCode = output.exitCode;
+}
+var checkCommand = new Command("run").description("Check project configuration and dependencies").option(
+  "-s, --scope <scope>",
+  "Check scope: all | build | ci | deploy | testing | layer1 | layer2 | layer3 | layer4",
+  "all"
+).option("--fix", "Attempt to auto-fix issues").option("-v, --verbose", "Show detailed output with fix hints").option("--dry-run", "Show what would be checked without running").option("--cwd <path>", "Working directory (default: current directory)").action(async (options) => {
+  try {
+    await runCheckAction(options);
+  } catch (error) {
+    if (error instanceof CLIError) {
+      throw error;
+    }
+    const err = error instanceof Error ? error : new Error(String(error));
+    throw new CLIError(
+      `Project check failed: ${err.message}`,
+      "CHECK_ERROR",
+      ["Check error details above", "Verify environment setup", "Try: runa check --verbose"],
+      err
+    );
+  }
+});
+
+export { checkCommand, runCheckAction as runCheckCommand };

package/dist/chunk-22CS6EMA.js

@@ -0,0 +1,31 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+
+createRequire(import.meta.url);
+
+// src/validators/risk-detector.ts
+init_esm_shims();
+var riskDetectorModulePromise = null;
+async function loadRiskDetectorModule() {
+  if (!riskDetectorModulePromise) {
+    riskDetectorModulePromise = import('./risk-detector-core-O7I7SPR7.js').catch((error) => {
+      riskDetectorModulePromise = null;
+      throw error;
+    });
+  }
+  return riskDetectorModulePromise;
+}
+async function detectSchemaRisks(filePath) {
+  const module = await loadRiskDetectorModule();
+  return module.detectSchemaRisks(filePath);
+}
+function categorizeRisks(risks) {
+  return {
+    high: risks.filter((r) => r.level === "high"),
+    medium: risks.filter((r) => r.level === "medium"),
+    low: risks.filter((r) => r.level === "low")
+  };
+}
+
+export { categorizeRisks, detectSchemaRisks };