@runa-ai/runa-cli 0.5.72 → 0.6.0

package/dist/chunk-5NKWR4FF.js

@@ -0,0 +1,254 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { findPackage, findWorkspaceRoot } from './chunk-JMJP4A47.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, readFileSync } from 'fs';
+import path, { join } from 'path';
+import { loadRunaConfigOrThrow } from '@runa-ai/runa';
+
+createRequire(import.meta.url);
+
+// src/utils/config-loader.ts
+init_esm_shims();
+function getDefaultDrizzlePaths(isMonorepo2) {
+  if (!isMonorepo2) {
+    return { schemaPath: "src/schema", outputPath: "src/zod" };
+  }
+  const workspaceRoot = findWorkspaceRoot(process.cwd()) || process.cwd();
+  const databaseSchemaDir = join(workspaceRoot, "packages", "database", "src", "schema");
+  if (existsSync(databaseSchemaDir)) {
+    return {
+      schemaPath: "packages/database/src/schema",
+      outputPath: "packages/database/src/zod"
+    };
+  }
+  return {
+    schemaPath: "packages/db/src/schema",
+    outputPath: "packages/db/src/zod"
+  };
+}
+var _configCache = /* @__PURE__ */ new Map();
+function loadRunaConfig(cwd = process.cwd()) {
+  const cached = _configCache.get(cwd);
+  if (cached) return cached;
+  const config = loadRunaConfigOrThrow(cwd).config;
+  _configCache.set(cwd, config);
+  return config;
+}
+function getDatabaseConfig(config) {
+  const dbConfig = config.database;
+  if (!dbConfig) {
+    const defaults = getDefaultDrizzlePaths(config.project.monorepo ?? false);
+    return {
+      type: "supabase",
+      schemaPath: defaults.schemaPath,
+      outputPath: defaults.outputPath
+    };
+  }
+  if (dbConfig.type === "supabase" || dbConfig.type === void 0) {
+    const defaults = getDefaultDrizzlePaths(config.project.monorepo ?? false);
+    return {
+      type: "supabase",
+      schemaPath: dbConfig.drizzle?.schemaPath || defaults.schemaPath,
+      outputPath: dbConfig.drizzle?.outputPath || defaults.outputPath
+    };
+  }
+  return {
+    type: "none",
+    schemaPath: "",
+    outputPath: ""
+  };
+}
+function getAppConfig(config) {
+  return {
+    directory: config.app?.directory || ".",
+    framework: config.app?.framework || "next"
+  };
+}
+function getDeployConfig(config) {
+  const preview = config.deploy?.environments?.preview || "preview";
+  const production = config.deploy?.environments?.production || "production";
+  return {
+    provider: config.deploy?.provider || "vercel",
+    environments: {
+      preview,
+      production
+    }
+  };
+}
+function isMonorepo(config) {
+  return config.project.monorepo ?? false;
+}
+function validateProjectName(config, errors) {
+  if (!config.project.name) {
+    errors.push("project.name is required");
+  }
+}
+function validateFramework(config, errors) {
+  if (config.app?.framework) {
+    const validFrameworks = ["next", "vite", "remix"];
+    if (!validFrameworks.includes(config.app.framework)) {
+      errors.push(
+        `app.framework must be one of: ${validFrameworks.join(", ")} (got: ${config.app.framework})`
+      );
+    }
+  }
+}
+function validateDeploymentProvider(config, errors) {
+  if (config.deploy?.provider) {
+    const validProviders = ["vercel", "cloudflare", "amplify", "none"];
+    if (!validProviders.includes(config.deploy.provider)) {
+      errors.push(
+        `deploy.provider must be one of: ${validProviders.join(", ")} (got: ${config.deploy.provider})`
+      );
+    }
+  }
+}
+function validateDatabaseType(config, errors) {
+  if (config.database?.type) {
+    const validTypes = ["supabase", "none"];
+    if (!validTypes.includes(config.database.type)) {
+      errors.push(
+        `database.type must be one of: ${validTypes.join(", ")} (got: ${config.database.type})`
+      );
+    }
+  }
+}
+function validateDrizzleConfig(config, errors) {
+  if (config.database?.drizzle) {
+    if (config.database.drizzle.schemaPath && !config.database.drizzle.schemaPath.trim()) {
+      errors.push("database.drizzle.schemaPath cannot be empty");
+    }
+    if (config.database.drizzle.outputPath && !config.database.drizzle.outputPath.trim()) {
+      errors.push("database.drizzle.outputPath cannot be empty");
+    }
+  }
+}
+function validateAppDirectory(config, errors) {
+  if (config.app?.directory && !config.app.directory.trim()) {
+    errors.push("app.directory cannot be empty");
+  }
+}
+function validateRunaConfig(config) {
+  const errors = [];
+  validateProjectName(config, errors);
+  validateFramework(config, errors);
+  validateDeploymentProvider(config, errors);
+  validateDatabaseType(config, errors);
+  validateDrizzleConfig(config, errors);
+  validateAppDirectory(config, errors);
+  return {
+    valid: errors.length === 0,
+    errors
+  };
+}
+function hasValidDatabaseIndicators(dir) {
+  const hasPrimaryIndicator = existsSync(path.join(dir, "drizzle.config.ts")) || existsSync(path.join(dir, "supabase", "schemas")) || existsSync(path.join(dir, "src", "schema")) || existsSync(path.join(dir, "scripts", "db-sync.ts"));
+  if (hasPrimaryIndicator) {
+    return true;
+  }
+  const pkgJsonPath = path.join(dir, "package.json");
+  if (existsSync(pkgJsonPath)) {
+    try {
+      const pkgJson = JSON.parse(readFileSync(pkgJsonPath, "utf-8"));
+      const name = pkgJson.name?.toLowerCase() ?? "";
+      if (name.includes("database") || name.endsWith("-db") || name.endsWith("/db")) {
+        return true;
+      }
+    } catch {
+    }
+  }
+  return false;
+}
+function tryResolveFromConfig(cwd) {
+  try {
+    const loaded = loadRunaConfigOrThrow(cwd);
+    const configDir = path.dirname(loaded.configPath);
+    const config = loaded.config;
+    if (config.project.monorepo === false && hasValidDatabaseIndicators(configDir)) {
+      return configDir;
+    }
+    const dbConfig = getDatabaseConfig(config);
+    const schemaPath = dbConfig.schemaPath;
+    const dbPath = schemaPath.includes("/src/") ? schemaPath.split("/src/")[0] : schemaPath.startsWith("src/") ? "." : path.dirname(schemaPath);
+    const fullPath = dbPath === "." ? configDir : path.join(configDir, dbPath);
+    return existsSync(fullPath) ? fullPath : null;
+  } catch {
+    return null;
+  }
+}
+async function getDatabasePackagePath(cwd = process.cwd()) {
+  const configResult = tryResolveFromConfig(cwd);
+  if (configResult) return configResult;
+  const dbPackage = findPackage("database", cwd) ?? findPackage("db", cwd);
+  if (dbPackage) return dbPackage;
+  const baseDir = findWorkspaceRoot(cwd) || cwd;
+  const conventionalPaths = [
+    path.join(baseDir, "packages", "database"),
+    path.join(baseDir, "packages", "db"),
+    path.join(baseDir, "db"),
+    baseDir
+  ];
+  for (const candidate of conventionalPaths) {
+    if (existsSync(candidate) && hasValidDatabaseIndicators(candidate)) {
+      return candidate;
+    }
+  }
+  throw new Error(`\u274C Database package not found
+
+Expected locations:
+  - packages/database/ (monorepo structure, recommended)
+  - packages/db/ (monorepo structure, legacy)
+  - db/ (single-package structure)
+  - . (project root with drizzle.config.ts or supabase/schemas/)
+
+Valid indicators (at least one required):
+  - package.json
+  - drizzle.config.ts (Drizzle ORM)
+  - supabase/schemas/ (Supabase SQL-First)
+  - src/schema/ (TypeScript schemas)
+
+Solutions:
+  1. Run: runa init (generates structure)
+  2. Set project.monorepo: false in runa.config.ts for single-app
+  3. Ensure supabase/schemas/ exists for Supabase projects
+`);
+}
+async function getSDKScriptsPath(cwd = process.cwd()) {
+  const sdkPackage = findPackage("sdk", cwd);
+  if (sdkPackage) {
+    const scriptsPath = path.join(sdkPackage, "scripts");
+    if (existsSync(scriptsPath)) {
+      return scriptsPath;
+    }
+  }
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  const baseDir = workspaceRoot || cwd;
+  const installedPath = path.join(baseDir, "node_modules", "@runa-ai", "runa", "scripts");
+  if (existsSync(installedPath)) {
+    return installedPath;
+  }
+  throw new Error(
+    "\u274C SDK scripts directory not found\n\nExpected locations:\n  - packages/sdk/scripts (workspace development)\n  - node_modules/@runa-ai/runa/scripts (npm installed)\n\nSolutions:\n  1. Install @runa-ai/runa: pnpm add @runa-ai/runa\n  2. Check workspace structure: pnpm list @runa-ai/runa\n  3. Run: pnpm install (reinstall dependencies)\n"
+  );
+}
+async function getSDKTemplatesPath(cwd = process.cwd()) {
+  const sdkPackage = findPackage("sdk", cwd);
+  if (sdkPackage) {
+    const templatesPath = path.join(sdkPackage, "templates");
+    if (existsSync(templatesPath)) {
+      return templatesPath;
+    }
+  }
+  const workspaceRoot = findWorkspaceRoot(cwd);
+  const baseDir = workspaceRoot || cwd;
+  const installedPath = path.join(baseDir, "node_modules", "@runa-ai", "runa", "templates");
+  if (existsSync(installedPath)) {
+    return installedPath;
+  }
+  throw new Error(
+    "\u274C SDK templates directory not found\n\nExpected locations:\n  - packages/sdk/templates (workspace development)\n  - node_modules/@runa-ai/runa/templates (npm installed)\n\nSolutions:\n  1. Install @runa-ai/runa: pnpm add @runa-ai/runa\n  2. Check: ls node_modules/@runa-ai/runa/templates\n  3. Run: pnpm install (reinstall dependencies)\n"
+  );
+}
+
+export { getAppConfig, getDatabaseConfig, getDatabasePackagePath, getDeployConfig, getSDKScriptsPath, getSDKTemplatesPath, isMonorepo, loadRunaConfig, validateRunaConfig };

package/dist/chunk-6AALH2ED.js

@@ -0,0 +1,121 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, readFileSync, writeFileSync } from 'fs';
+import { resolve } from 'path';
+
+createRequire(import.meta.url);
+
+// src/utils/config-updater.ts
+init_esm_shims();
+var VALID_DIRECTORY_PATTERN = /^[a-zA-Z0-9.][a-zA-Z0-9/_.-]*$/;
+var VALID_VERSION_PATTERN = /^[0-9]+\.[0-9]+\.[0-9]+(?:-[a-zA-Z0-9.-]+)?$/;
+function isControlChar(charCode) {
+  return charCode <= 31 || charCode === 127;
+}
+function isValidDirectoryPath(dir) {
+  if (!dir || typeof dir !== "string") {
+    return false;
+  }
+  if (dir.trim() === "") {
+    return false;
+  }
+  if (/['"\\]/.test(dir)) {
+    return false;
+  }
+  for (let i = 0; i < dir.length; i++) {
+    if (isControlChar(dir.charCodeAt(i))) {
+      return false;
+    }
+  }
+  return VALID_DIRECTORY_PATTERN.test(dir);
+}
+function isValidVersion(version) {
+  if (!version || typeof version !== "string") {
+    return false;
+  }
+  return VALID_VERSION_PATTERN.test(version);
+}
+function escapeReplacementString(str) {
+  return str.replace(/\$/g, "$$$$");
+}
+function updateRunaConfigAppDirectory(appDirectory, targetDir = process.cwd()) {
+  if (!isValidDirectoryPath(appDirectory)) {
+    return { updated: false, reason: "Invalid directory path format" };
+  }
+  const configPath = resolve(targetDir, "runa.config.ts");
+  if (!existsSync(configPath)) {
+    return { updated: false, reason: "runa.config.ts not found" };
+  }
+  const content = readFileSync(configPath, "utf-8");
+  const currentMatch = content.match(/directory:\s*['"]([^'"]+)['"]/);
+  const currentValue = currentMatch?.[1];
+  if (currentValue && currentValue !== "." && currentValue !== "apps/web") {
+    if (currentValue === appDirectory) {
+      return { updated: false, reason: "Already set to the same value" };
+    }
+    return { updated: false, reason: `Already customized to '${currentValue}'` };
+  }
+  const directoryPattern = /(directory:\s*)(['"])([^'"]*)\2/;
+  if (!directoryPattern.test(content)) {
+    return { updated: false, reason: "Could not find directory field in config" };
+  }
+  const safeDirectory = escapeReplacementString(appDirectory);
+  const newContent = content.replace(directoryPattern, `$1'${safeDirectory}'`);
+  if (newContent === content) {
+    return { updated: false, reason: "No changes needed" };
+  }
+  writeFileSync(configPath, newContent, "utf-8");
+  return { updated: true, reason: `Updated to '${appDirectory}'` };
+}
+function syncRunaConfigWithVercel(targetDir, vercelRootDirectory) {
+  if (!vercelRootDirectory) {
+    return null;
+  }
+  const result = updateRunaConfigAppDirectory(vercelRootDirectory, targetDir);
+  return {
+    updated: result.updated,
+    field: "app.directory",
+    reason: result.reason
+  };
+}
+function updateRunaConfigSdkVersion(version, targetDir = process.cwd()) {
+  if (!isValidVersion(version)) {
+    return { updated: false, reason: "Invalid version format" };
+  }
+  const configPath = resolve(targetDir, "runa.config.ts");
+  if (!existsSync(configPath)) {
+    return { updated: false, reason: "runa.config.ts not found" };
+  }
+  const content = readFileSync(configPath, "utf-8");
+  const currentMatch = content.match(/sdkVersion:\s*['"]([^'"]+)['"]/);
+  const currentVersion = currentMatch?.[1];
+  if (currentVersion === version) {
+    return { updated: false, reason: "Already at this version" };
+  }
+  const sdkVersionPattern = /(sdkVersion:\s*)(['"])([^'"]*)\2/;
+  const safeVersion = escapeReplacementString(version);
+  if (sdkVersionPattern.test(content)) {
+    const newContent = content.replace(sdkVersionPattern, `$1'${safeVersion}'`);
+    if (newContent === content) {
+      return { updated: false, reason: "No changes needed" };
+    }
+    writeFileSync(configPath, newContent, "utf-8");
+    return {
+      updated: true,
+      reason: currentVersion ? `Updated from '${currentVersion}' to '${version}'` : `Set to '${version}'`
+    };
+  }
+  const configVersionPattern = /(configVersion:\s*\d+,?)(\s*\n)/;
+  if (configVersionPattern.test(content)) {
+    const newContent = content.replace(
+      configVersionPattern,
+      `$1$2  sdkVersion: '${safeVersion}',$2`
+    );
+    writeFileSync(configPath, newContent, "utf-8");
+    return { updated: true, reason: `Added sdkVersion: '${version}'` };
+  }
+  return { updated: false, reason: "Could not find appropriate location to add sdkVersion" };
+}
+
+export { syncRunaConfigWithVercel, updateRunaConfigSdkVersion };

package/dist/chunk-6Y3LAUGL.js

@@ -0,0 +1,35 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { CLIError } from '@runa-ai/runa/cli-runtime';
+
+createRequire(import.meta.url);
+
+// src/cli/non-interactive.ts
+init_esm_shims();
+function isTrueEnv(value) {
+  return value === "1" || value === "true" || value === "yes";
+}
+function isNonInteractiveEnabled() {
+  if (isTrueEnv(process.env.RUNA_NON_INTERACTIVE)) return true;
+  if (process.env.CI === "true") return true;
+  if (process.env.RUNA_OUTPUT_FORMAT === "json") return true;
+  return false;
+}
+function enableNonInteractiveMode() {
+  process.env.RUNA_NON_INTERACTIVE = "true";
+}
+function assertTtyRequired(featureName) {
+  const stdinTty = process.stdin.isTTY === true;
+  const stdoutTty = process.stdout.isTTY === true;
+  if (stdinTty && stdoutTty) return;
+  throw new CLIError(
+    `${featureName} requires an interactive TTY`,
+    "TTY_REQUIRED",
+    ["Run in a terminal (TTY)", "Avoid piping stdin/stdout when using TUI features"],
+    void 0,
+    2
+  );
+}
+
+export { assertTtyRequired, enableNonInteractiveMode, isNonInteractiveEnabled };

package/dist/chunk-7QV7U6NI.js

@@ -0,0 +1,62 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { redactSecrets } from './chunk-II7VYQEM.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { createWriteStream } from 'fs';
+import { mkdir } from 'fs/promises';
+import path from 'path';
+import { execa } from 'execa';
+
+createRequire(import.meta.url);
+
+// src/commands/ci/utils/execa-helpers.ts
+init_esm_shims();
+function redactArgsForLog(args) {
+  return args.map((a) => redactSecrets(a));
+}
+function pipeToSharedLog(params) {
+  let pending = 0;
+  const maybeEnd = () => {
+    if (pending !== 0) return;
+    try {
+      params.logStream.end();
+    } catch (error) {
+    }
+  };
+  for (const s of params.streams) {
+    if (!s) continue;
+    pending += 1;
+    s.pipe(params.logStream, { end: false });
+    const done = () => {
+      pending -= 1;
+      maybeEnd();
+    };
+    s.once("end", done);
+    s.once("close", done);
+    s.once("error", done);
+  }
+  maybeEnd();
+}
+async function ensureRunaTmpDir(cwd) {
+  const root = cwd ?? process.cwd();
+  const dir = path.join(root, ".runa", "tmp");
+  await mkdir(dir, { recursive: true });
+  return dir;
+}
+function runLogged(params) {
+  console.log(`\u25B6 ${params.label}: ${params.command} ${redactArgsForLog(params.args).join(" ")}`);
+  const proc = execa(params.command, params.args, {
+    cwd: params.cwd,
+    env: { DOTENVX_QUIET: "1", ...params.env },
+    stdio: ["ignore", "pipe", "pipe"],
+    shell: false,
+    timeout: params.timeoutMs
+  });
+  const stream = createWriteStream(params.logFile, { flags: "a" });
+  if (proc.stdout) proc.stdout.pipe(process.stdout, { end: false });
+  if (proc.stderr) proc.stderr.pipe(process.stderr, { end: false });
+  pipeToSharedLog({ streams: [proc.stdout, proc.stderr], logStream: stream });
+  return proc;
+}
+
+export { ensureRunaTmpDir, runLogged };

package/dist/chunk-AAIE4F2U.js

@@ -0,0 +1,140 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { secureDocker, secureExeca } from './chunk-RZLYEO4U.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync, readFileSync } from 'fs';
+import path from 'path';
+
+createRequire(import.meta.url);
+
+// src/utils/diagnostics.ts
+init_esm_shims();
+async function checkDocker() {
+  try {
+    await secureDocker(["ps"]);
+    return {
+      severity: "info",
+      message: "Docker is running"
+    };
+  } catch {
+    return {
+      severity: "error",
+      message: "Docker is not running or not installed",
+      fixInstructions: [
+        "Start Colima: colima start --cpu 4 --memory 8 --disk 60 --vm-type vz --mount-type virtiofs",
+        "Install Colima: brew install colima docker",
+        "Linux: sudo systemctl start docker"
+      ]
+    };
+  }
+}
+async function checkPort(port) {
+  try {
+    const result = await secureExeca("lsof", ["-i", `:${port}`]);
+    const stdout = typeof result.stdout === "string" ? result.stdout : "";
+    const lines = stdout.trim().split("\n");
+    if (lines.length > 1) {
+      const processInfo = lines[1].split(/\s+/);
+      const processName = processInfo[0];
+      const pid = processInfo[1];
+      return {
+        severity: "warning",
+        message: `Port ${port} is in use by ${processName} (PID: ${pid})`,
+        fixInstructions: [
+          `Kill the process: kill ${pid}`,
+          "Or use a different port in your configuration"
+        ]
+      };
+    }
+  } catch {
+  }
+  return {
+    severity: "info",
+    message: `Port ${port} is available`
+  };
+}
+function detectSupabasePortsFromConfig() {
+  const configPath = path.join(process.cwd(), "supabase", "config.toml");
+  const BASE_PORTS = { api: 54321, db: 54322, studio: 54323, inbucket: 54324 };
+  if (!existsSync(configPath)) {
+    return Object.values(BASE_PORTS);
+  }
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    const ports = [];
+    const apiMatch = content.match(/\[api\][\s\S]*?port\s*=\s*(\d+)/);
+    ports.push(apiMatch ? Number.parseInt(apiMatch[1], 10) : BASE_PORTS.api);
+    const dbMatch = content.match(/\[db\][\s\S]*?port\s*=\s*(\d+)/);
+    ports.push(dbMatch ? Number.parseInt(dbMatch[1], 10) : BASE_PORTS.db);
+    const studioMatch = content.match(/\[studio\][\s\S]*?port\s*=\s*(\d+)/);
+    ports.push(studioMatch ? Number.parseInt(studioMatch[1], 10) : BASE_PORTS.studio);
+    const inbucketMatch = content.match(/\[inbucket\][\s\S]*?port\s*=\s*(\d+)/);
+    ports.push(inbucketMatch ? Number.parseInt(inbucketMatch[1], 10) : BASE_PORTS.inbucket);
+    return ports;
+  } catch {
+    return Object.values(BASE_PORTS);
+  }
+}
+async function checkSupabasePorts() {
+  const ports = detectSupabasePortsFromConfig();
+  const results = [];
+  for (const port of ports) {
+    const result = await checkPort(port);
+    if (result.severity !== "info") {
+      results.push(result);
+    }
+  }
+  return results;
+}
+function checkRequiredFiles(files) {
+  const results = [];
+  for (const file of files) {
+    if (!existsSync(file)) {
+      results.push({
+        severity: "error",
+        message: `Required file not found: ${file}`,
+        fixInstructions: [`Create ${file} or run 'runa init' to set up the project`]
+      });
+    }
+  }
+  return results;
+}
+async function diagnoseSupabaseStart() {
+  const results = [];
+  const dockerCheck = await checkDocker();
+  if (dockerCheck.severity === "error") {
+    results.push(dockerCheck);
+  }
+  const portChecks = await checkSupabasePorts();
+  results.push(...portChecks);
+  const configCheck = checkRequiredFiles(["supabase/config.toml"]);
+  results.push(...configCheck);
+  return results;
+}
+function diagnoseInitFailure(errorMessage) {
+  const results = [];
+  if (errorMessage.includes("templates directory not found")) {
+    results.push({
+      severity: "error",
+      message: "@runa-ai/runa is not installed correctly",
+      fixInstructions: [
+        "Verify installation: pnpm list @runa-ai/runa",
+        "Reinstall: pnpm add -D @runa-ai/runa",
+        "Ensure you are in the project root directory"
+      ]
+    });
+  }
+  if (errorMessage.includes("package.json")) {
+    results.push({
+      severity: "error",
+      message: "Not in a valid Node.js project",
+      fixInstructions: [
+        "Run from project root (where package.json exists)",
+        "Or initialize new project: pnpm init"
+      ]
+    });
+  }
+  return results;
+}
+
+export { diagnoseInitFailure, diagnoseSupabaseStart };

package/dist/chunk-CCKG5R4Y.js

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+import { createRequire } from 'module';
+import { getDatabasePackagePath } from './chunk-5NKWR4FF.js';
+import { init_esm_shims } from './chunk-VRXHCR5K.js';
+import { existsSync } from 'fs';
+import { join } from 'path';
+
+createRequire(import.meta.url);
+
+// src/commands/db/utils/stack-detector.ts
+init_esm_shims();
+async function detectDatabaseStack(cwd = process.cwd()) {
+  try {
+    const dbPackagePath = await getDatabasePackagePath(cwd);
+    const drizzleConfig = join(dbPackagePath, "drizzle.config.ts");
+    if (existsSync(drizzleConfig)) {
+      return {
+        stack: "drizzle",
+        confidence: "high",
+        reason: `Found drizzle.config.ts at ${dbPackagePath}`,
+        paths: { drizzleConfig }
+      };
+    }
+  } catch {
+  }
+  const supabaseSchemas = join(cwd, "supabase/schemas");
+  if (existsSync(supabaseSchemas)) {
+    return {
+      stack: "supabase",
+      confidence: "high",
+      reason: "Found supabase/schemas/ directory",
+      paths: { supabaseSchemas }
+    };
+  }
+  throw new Error(
+    "Unable to detect database stack.\nExpected one of:\n  - drizzle.config.ts in database package (Drizzle ORM)\n  - supabase/schemas/ (Supabase SQL)\n\nRun `runa init` to set up your database structure."
+  );
+}
+async function getStackPaths(stack, cwd = process.cwd()) {
+  if (stack === "drizzle") {
+    const dbPath = await getDatabasePackagePath(cwd);
+    return {
+      rootDir: dbPath,
+      schemaDir: join(dbPath, "src/schema"),
+      configFile: join(dbPath, "drizzle.config.ts")
+    };
+  }
+  if (stack === "supabase") {
+    const schemasDir = join(cwd, "supabase/schemas");
+    return {
+      rootDir: join(cwd, "supabase"),
+      schemaDir: schemasDir,
+      configFile: join(cwd, "supabase/config.toml")
+    };
+  }
+  throw new Error(`Unknown stack: ${stack}`);
+}
+
+export { detectDatabaseStack, getStackPaths };