@runa-ai/runa-cli 0.10.1 → 0.10.3

package/dist/index.js

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
 import { getRequestedCommandNameFromArgv } from './chunk-UWWSAPDR.js';
-import { CLI_VERSION } from './chunk-ZPE52NEK.js';
+import { CLI_VERSION } from './chunk-SS7RIWW3.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { realpathSync } from 'fs';
 import { fileURLToPath } from 'url';
@@ -36,7 +36,7 @@ async function getProgram(options) {
   };
   const nextKey = getProgramCacheKey(resolvedOptions);
   if (!programInstance || programCacheKey !== nextKey) {
-    const { createProgram } = await import('./cli-RES5QRC2.js');
+    const { createProgram } = await import('./cli-Q665YRVT.js');
     programInstance = await createProgram(resolvedOptions);
     programCacheKey = nextKey;
   }
@@ -60,7 +60,7 @@ async function runCliFromProcessArgv() {
     return;
   }
   const { setupSignalHandlers } = await import('./signal-handler-DO3OANW5.js');
-  const { executeProgram } = await import('./cli-RES5QRC2.js');
+  const { executeProgram } = await import('./cli-Q665YRVT.js');
   setupSignalHandlers();
   const options = getProgramLoadOptions(argv);
   const program = await getProgram(options);

package/dist/{risk-detector-S7XQF4I2.js → risk-detector-GDDLISVE.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-export { categorizeRisks, detectSchemaRisks } from './chunk-PAWNJA3N.js';
+export { categorizeRisks, detectSchemaRisks } from './chunk-XFXGFUAM.js';
 import './chunk-VRXHCR5K.js';
 
 createRequire(import.meta.url);

package/dist/{risk-detector-core-TGFKWHRS.js → risk-detector-core-YI3M6INI.js}

@@ -54,7 +54,7 @@ var UNQUALIFIED_EXTENSION_REFERENCE_PATTERNS = [
 var plpgsqlModulePromise = null;
 async function loadPlpgsqlRiskDetectorModule() {
   if (!plpgsqlModulePromise) {
-    plpgsqlModulePromise = import('./risk-detector-plpgsql-O32TUR34.js').catch((error) => {
+    plpgsqlModulePromise = import('./risk-detector-plpgsql-4GWEQXUG.js').catch((error) => {
       plpgsqlModulePromise = null;
       throw error;
     });

package/dist/{risk-detector-plpgsql-O32TUR34.js → risk-detector-plpgsql-4GWEQXUG.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { splitPlpgsqlStatementsWithOffsets, parseTopLevelAssignment, extractExecuteExpressions, skipWhitespace, extractStaticSqlFromExpression, mergeStringEnvValue, skipIdentifier } from './chunk-Y5ANTCKE.js';
+import { splitPlpgsqlStatementsWithOffsets, parseTopLevelAssignment, extractExecuteExpressions, skipWhitespace, extractStaticSqlFromExpression, mergeStringEnvValue, skipIdentifier } from './chunk-EZ46JIEO.js';
 import { stripSqlCommentsPreserveLines, buildLineStarts, lineNumberFromIndex, stripSqlStringsPreserveLines, detectRisksFromContent, stripSqlForPatternMatching } from './chunk-3FDQW524.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 

package/dist/{template-check-VNNQQXCX.js → template-check-D35F2GDP.js}

@@ -138,6 +138,10 @@ var RUNA_ONLY_FILES = [
   "packages/database/scripts/db-sync-db-state.test.ts",
   "packages/database/scripts/db-sync-local-url.test.ts",
   "packages/database/scripts/db-sync-pg-schema-diff.test.ts",
+  "packages/database/scripts/db-sync-shadow-db.ts",
+  // Shadow DB diffing helper (runa-repo internal)
+  "packages/database/scripts/db-sync-shadow-db.test.ts",
+  // Shadow DB tests (runa-repo internal)
   "packages/database/scripts/db-sync-schema-discovery.test.ts",
   "packages/database/scripts/db-sync-schema-sort.ts",
   "packages/database/scripts/db-sync-seeds-runtime.test.ts",

package/dist/{upgrade-LBO3Z3J7.js → upgrade-X7P6WRD5.js}

@@ -8,7 +8,9 @@ import { emitJsonSuccess } from './chunk-KE6QJBZG.js';
 import './chunk-WJXC4MVY.js';
 import './chunk-HKUWEGUX.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
-import { createCLILogger, CLIError, UpgradeTransaction, readRunaVersion, syncTemplates, SyncOutputSchema, findConflictFiles, preCheckSync } from '@runa-ai/runa';
+import { existsSync, readdirSync, statSync, readFileSync } from 'fs';
+import { join, extname } from 'path';
+import { createCLILogger, CLIError, loadRunaConfig, UpgradeTransaction, readRunaVersion, syncTemplates, SyncOutputSchema, findConflictFiles, preCheckSync } from '@runa-ai/runa';
 import { Command } from 'commander';
 import { execa } from 'execa';
 
@@ -36,6 +38,154 @@ function parseOnlyOption(only) {
   }
   return valid;
 }
+var MERGE_MARKER_PATTERN = /^<{7}\s|^={7}$|^>{7}\s/m;
+var MERGE_MARKER_SCAN_EXTENSIONS = [
+  ".ts",
+  ".tsx",
+  ".js",
+  ".jsx",
+  ".md",
+  ".yml",
+  ".yaml",
+  ".json",
+  ".toml"
+];
+var MERGE_MARKER_SCAN_DIRS = [".claude", ".codex", ".github", "supabase"];
+var MERGE_MARKER_SKIP_DIRS = ["node_modules", ".git", "dist"];
+var MERGE_MARKER_ROOT_FILES = [
+  "AGENTS.md",
+  "CLAUDE.md",
+  "runa.config.ts",
+  "biome.json",
+  "turbo.json",
+  "vercel.json",
+  ".env.example",
+  ".npmrc"
+];
+function fileHasMergeMarkers(filePath) {
+  try {
+    return MERGE_MARKER_PATTERN.test(readFileSync(filePath, "utf-8"));
+  } catch {
+    return false;
+  }
+}
+function shouldScanMergeMarkerEntry(entry) {
+  return MERGE_MARKER_SCAN_EXTENSIONS.includes(extname(entry).toLowerCase());
+}
+function scanDirForMergeMarkers(dir, relativePath, results) {
+  let entries;
+  try {
+    entries = readdirSync(dir);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (MERGE_MARKER_SKIP_DIRS.includes(entry)) continue;
+    const fullPath = join(dir, entry);
+    const relPath = join(relativePath, entry);
+    try {
+      const stats = statSync(fullPath);
+      if (stats.isDirectory()) {
+        scanDirForMergeMarkers(fullPath, relPath, results);
+        continue;
+      }
+      if (stats.isFile() && shouldScanMergeMarkerEntry(entry) && fileHasMergeMarkers(fullPath)) {
+        results.push(relPath);
+      }
+    } catch {
+    }
+  }
+}
+function findFilesWithMergeMarkers(targetDir) {
+  const filesWithMarkers = [];
+  for (const checkDir of MERGE_MARKER_SCAN_DIRS) {
+    const dirPath = join(targetDir, checkDir);
+    if (existsSync(dirPath)) {
+      scanDirForMergeMarkers(dirPath, checkDir, filesWithMarkers);
+    }
+  }
+  for (const file of MERGE_MARKER_ROOT_FILES) {
+    const filePath = join(targetDir, file);
+    if (existsSync(filePath) && fileHasMergeMarkers(filePath)) {
+      filesWithMarkers.push(file);
+    }
+  }
+  return filesWithMarkers.sort();
+}
+function assertNoExistingMergeMarkers(targetDir) {
+  const filesWithMarkers = findFilesWithMergeMarkers(targetDir);
+  if (filesWithMarkers.length === 0) return;
+  throw new CLIError(
+    `${filesWithMarkers.length} file(s) have unresolved or partial merge markers`,
+    "UPGRADE_EXISTING_MERGE_MARKERS",
+    [
+      `Files: ${filesWithMarkers.slice(0, 5).join(", ")}${filesWithMarkers.length > 5 ? ` and ${filesWithMarkers.length - 5} more` : ""}`,
+      "Resolve previous merge markers before running `runa upgrade` again",
+      "Then run: runa check"
+    ]
+  );
+}
+function loadUpgradeConflictResolutionConfig(cwd = process.cwd()) {
+  const loaded = loadRunaConfig(cwd);
+  const conflictResolution = loaded?.config.upgrade?.conflictResolution;
+  return {
+    defaultStrategy: conflictResolution?.default ?? "manual",
+    rules: conflictResolution?.rules ?? []
+  };
+}
+async function resolveInstalledCliTemplatesVersion(cwd = process.cwd()) {
+  const script = `
+const fs = require('node:fs');
+const path = require('node:path');
+const entry = require.resolve('@runa-ai/runa-cli');
+const versionsPath = path.join(path.dirname(entry), 'constants', 'versions.js');
+const content = fs.readFileSync(versionsPath, 'utf-8');
+const match = content.match(/COMPATIBLE_TEMPLATES_VERSION\\s*=\\s*['"]([^'"]+)['"]/);
+if (!match) process.exit(2);
+process.stdout.write(match[1]);
+`;
+  try {
+    const result = await execa("pnpm", ["exec", "node", "-e", script], {
+      cwd,
+      stdio: "pipe"
+    });
+    return result.stdout.trim() || null;
+  } catch {
+    return null;
+  }
+}
+async function resolveTemplatesVersionForUpgrade(params) {
+  if (params.options.templatesVersion) {
+    return params.options.templatesVersion;
+  }
+  if (params.options.preview && params.shouldUpdatePackages) {
+    throw new CLIError(
+      "Preview cannot determine target template compatibility before package installation",
+      "UPGRADE_PREVIEW_TEMPLATE_PARITY_UNKNOWN",
+      [
+        "Run without --preview to install packages first",
+        "Or pass --templates-version <version> explicitly",
+        "Or run with --no-packages for template-only preview"
+      ]
+    );
+  }
+  const installedVersion = await resolveInstalledCliTemplatesVersion(params.cwd);
+  if (installedVersion) {
+    return installedVersion;
+  }
+  if (params.shouldUpdatePackages) {
+    throw new CLIError(
+      "Could not determine compatible templates version from the installed local CLI",
+      "UPGRADE_TEMPLATE_PARITY_UNRESOLVED",
+      [
+        "Ensure @runa-ai/runa-cli is installed locally",
+        "Re-run `runa upgrade` after package installation succeeds",
+        "Or pass --templates-version <version> explicitly"
+      ]
+    );
+  }
+  return void 0;
+}
 function logVersionInfo(logger, preCheck) {
   if (preCheck.versionJump) {
     const { from, to, isMajor, distance } = preCheck.versionJump;
@@ -381,12 +531,16 @@ async function getInstalledVersion(packageName) {
     return "unknown";
   }
 }
-async function runPreCheck(logger, options, isNonInteractive, templatesDir) {
+async function runPreCheck(logger, options, isNonInteractive, templatesDir, conflictResolution) {
   if (options.force || options.keepLocal) return;
   const preCheck = await preCheckSync({
     targetDir: process.cwd(),
     mode: "sync",
-    templatesDir
+    templatesDir,
+    conflictResolution: {
+      defaultStrategy: conflictResolution.defaultStrategy,
+      rules: conflictResolution.rules
+    }
   });
   logVersionInfo(logger, preCheck);
   logConflictSummary(logger, preCheck, isNonInteractive, options.preview === true);
@@ -451,9 +605,9 @@ async function executePackageUpdate(logger, options) {
   }
 }
 async function executeTemplateSync(ctx, templatesDir) {
-  const { logger, options, onlyCategories, isNonInteractive } = ctx;
+  const { logger, options, onlyCategories, isNonInteractive, conflictResolution } = ctx;
   logger.section("Upgrade SDK Templates");
-  await runPreCheck(logger, options, isNonInteractive, templatesDir);
+  await runPreCheck(logger, options, isNonInteractive, templatesDir, conflictResolution);
   logModeInfo(logger, options, onlyCategories);
   const result = await syncTemplates({
     targetDir: process.cwd(),
@@ -463,7 +617,11 @@ async function executeTemplateSync(ctx, templatesDir) {
     keepLocal: options.keepLocal === true,
     keepBackup: options.backup === true,
     only: onlyCategories.length > 0 ? onlyCategories : void 0,
-    templatesDir
+    templatesDir,
+    conflictResolution: {
+      defaultStrategy: conflictResolution.defaultStrategy,
+      rules: conflictResolution.rules
+    }
   });
   emitJsonSuccess(upgradeCommand, SyncOutputSchema, result);
   logHumanOutput(logger, result, options);
@@ -492,20 +650,28 @@ async function executeVerification(logger) {
   }
 }
 async function executeUpgrade(ctx) {
-  const { logger, options, shouldUpdatePackages } = ctx;
-  logger.section("Fetching Templates");
-  const templateResult = await fetchTemplates({
-    version: options.templatesVersion,
-    fresh: options.fresh,
-    verbose: process.env.DEBUG === "true"
-  });
-  logger.info(
-    templateResult.cached ? `Using ${templateResult.version === "workspace" ? "workspace" : "cached"} templates v${templateResult.version}` : `Fetched templates v${templateResult.version}`
-  );
+  const { logger, options, shouldUpdatePackages, shouldSyncTemplates } = ctx;
+  assertNoExistingMergeMarkers(process.cwd());
   if (shouldUpdatePackages) {
     await executePackageUpdate(logger, options);
   }
-  await executeTemplateSync(ctx, templateResult.templatesDir);
+  if (shouldSyncTemplates) {
+    const templatesVersion = await resolveTemplatesVersionForUpgrade({
+      cwd: process.cwd(),
+      options,
+      shouldUpdatePackages
+    });
+    logger.section("Fetching Templates");
+    const templateResult = await fetchTemplates({
+      version: templatesVersion,
+      fresh: options.fresh,
+      verbose: process.env.DEBUG === "true"
+    });
+    logger.info(
+      templateResult.cached ? `Using ${templateResult.version === "workspace" ? "workspace" : "cached"} templates v${templateResult.version}` : `Fetched templates v${templateResult.version}`
+    );
+    await executeTemplateSync(ctx, templateResult.templatesDir);
+  }
   if (options.verify && !options.preview) {
     await executeVerification(logger);
   }
@@ -607,14 +773,18 @@ var upgradeCommand = new Command("upgrade").description("Upgrade SDK packages an
   }
   const onlyCategories = parseOnlyOption(options.only);
   const shouldUpdatePackages = options.packages !== false && (onlyCategories.length === 0 || onlyCategories.includes("packages"));
+  const shouldSyncTemplates = onlyCategories.length === 0 || onlyCategories.some((category) => category !== "packages");
   const isJsonMode = process.env.RUNA_OUTPUT_FORMAT === "json";
   const isNonInteractive = options.yes || isJsonMode || !process.stdin.isTTY;
+  const conflictResolution = loadUpgradeConflictResolutionConfig(process.cwd());
   const ctx = {
     logger,
     options,
     onlyCategories,
     shouldUpdatePackages,
-    isNonInteractive
+    shouldSyncTemplates,
+    isNonInteractive,
+    conflictResolution
   };
   try {
     await executeUpgrade(ctx);
@@ -634,4 +804,4 @@ var upgradeCommand = new Command("upgrade").description("Upgrade SDK packages an
   }
 });
 
-export { upgradeCommand };
+export { assertNoExistingMergeMarkers, findFilesWithMergeMarkers, loadUpgradeConflictResolutionConfig, resolveTemplatesVersionForUpgrade, upgradeCommand };

package/dist/{vuln-check-5JJ2YAJW.js → vuln-check-WW43E7PS.js}

@@ -71,7 +71,7 @@ var vulnCheckCommand = new Command("vuln-check").description("Run comprehensive
   const logger = createCLILogger("vuln-check");
   const isJsonMode = getOutputFormatFromEnv() === "json" || options.format === "json";
   try {
-    const { VulnChecker } = await import('./vuln-checker-JF5234BL.js');
+    const { VulnChecker } = await import('./vuln-checker-BC3ZAXJ3.js');
     const categoryMap = {
       code: ["injection", "auth", "crypto"],
       deps: ["dependency"],

package/dist/{vuln-checker-JF5234BL.js → vuln-checker-BC3ZAXJ3.js}

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { createRequire } from 'module';
-import { CLI_VERSION } from './chunk-ZPE52NEK.js';
+import { CLI_VERSION } from './chunk-SS7RIWW3.js';
 import { init_esm_shims } from './chunk-VRXHCR5K.js';
 import { glob } from 'glob';
 import { exec } from 'child_process';

package/dist/{watch-RFVCEQLH.js → watch-4RHXVCQ3.js}

@@ -284,7 +284,7 @@ function validateSqlSchema(content, errors, warnings) {
 var riskDetectorLoader = null;
 function loadRiskDetectorModule() {
   if (!riskDetectorLoader) {
-    riskDetectorLoader = import('./risk-detector-S7XQF4I2.js').then((module) => ({
+    riskDetectorLoader = import('./risk-detector-GDDLISVE.js').then((module) => ({
       detectSchemaRisks: module.detectSchemaRisks
     })).catch((error) => {
       riskDetectorLoader = null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@runa-ai/runa-cli",
-  "version": "0.10.1",
+  "version": "0.10.3",
   "private": false,
   "description": "AI-powered DevOps CLI",
   "type": "module",