@stacksjs/buddy 0.70.59 → 0.70.61

package/dist/lazy-commands.d.ts

@@ -0,0 +1,61 @@
+import type { CLI } from '@stacksjs/types';
+/** Mark a registrar as already invoked for this CLI so loadCommand skips it. */
+export declare function markLoaded(buddy: CLI, commandName: string): void;
+/**
+ * Load a specific command lazily
+ */
+export declare function loadCommand(commandName: string, buddy: CLI): Promise<boolean>;
+/**
+ * Load multiple commands with timeout.
+ *
+ * Many registry entries point at the same module (e.g. `down`, `up`, `status`,
+ * `maintenance` all share `./commands/maintenance.ts`, and `cloud:*` aliases
+ * share `./commands/cloud.ts`). Calling each registrar more than once would
+ * register the same sub-commands multiple times, which is what produces
+ * duplicate rows in `buddy list`. Dedupe by loader identity so each module's
+ * registrar runs at most once per CLI instance.
+ */
+export declare function loadCommands(commandNames: string[], buddy: CLI): Promise<void>;
+/**
+ * Load a group of related commands
+ */
+export declare function loadCommandGroup(groupName: keyof typeof commandGroups, buddy: CLI): Promise<void>;
+/**
+ * Load all commands (for interactive mode or list command)
+ */
+export declare function loadAllCommands(buddy: CLI): Promise<void>;
+/**
+ * Get command names for autocomplete/suggestions
+ * (without actually loading the commands)
+ */
+export declare function getCommandNames(): string[];
+/**
+ * Determine which commands to load based on CLI arguments.
+ *
+ * Help / no-command paths must load the full registry so the rendered help
+ * lists every command. Pure version flags only need `version`. A specific
+ * command (with or without `--help`) only needs that command's loader.
+ */
+export declare function getCommandsToLoad(args: string[]): string[];
+/**
+ * Commands that are commonly used together (for batch loading optimization)
+ * @defaultValue
+ * ```ts
+ * {
+ *   'minimal': ['version', 'help'],
+ *   'development': ['dev', 'build', 'test', 'lint'],
+ *   'database': ['migrate', 'seed', 'fresh'],
+ *   'scaffolding': ['make', 'generate'],
+ *   'deployment': ['deploy', 'release', 'cloud'],
+ *   'info': ['about', 'doctor', 'list']
+ * }
+ * ```
+ */
+declare const commandGroups: {
+  'minimal': string[];
+  'development': string[];
+  'database': string[];
+  'scaffolding': string[];
+  'deployment': string[];
+  'info': string[]
+};

package/dist/lazy-commands.js

@@ -0,0 +1,182 @@
+const commandRegistry = {
+  about: { path: "./commands/about.js", exportName: "about" },
+  add: { path: "./commands/add.js", exportName: "add" },
+  auth: { path: "./commands/auth.js", exportName: "auth" },
+  build: { path: "./commands/build.js", exportName: "build" },
+  cd: { path: "./commands/cd.js", exportName: "cd" },
+  changelog: { path: "./commands/changelog.js", exportName: "changelog" },
+  clean: { path: "./commands/clean.js", exportName: "clean" },
+  cloud: { path: "./commands/cloud.js", exportName: "cloud" },
+  commit: { path: "./commands/commit.js", exportName: "commit" },
+  completion: { path: "./commands/completion.js", exportName: "completion" },
+  "config:migrate": { path: "./commands/config-migrate.js", exportName: "configMigrate" },
+  configure: { path: "./commands/configure.js", exportName: "configure" },
+  create: { path: "./commands/create.js", exportName: "create" },
+  deploy: { path: "./commands/deploy.js", exportName: "deploy" },
+  dev: { path: "./commands/dev.js", exportName: "dev" },
+  dns: { path: "./commands/dns.js", exportName: "dns" },
+  doctor: { path: "./commands/doctor.js", exportName: "doctor" },
+  domains: { path: "./commands/domains.js", exportName: "domains" },
+  email: { path: "./commands/email.js", exportName: "email" },
+  env: { path: "./commands/env.js", exportName: "env" },
+  "dashboard:install": { path: "./commands/features.js", exportName: "features" },
+  "dashboard:uninstall": { path: "./commands/features.js", exportName: "features" },
+  "commerce:install": { path: "./commands/features.js", exportName: "features" },
+  "commerce:uninstall": { path: "./commands/features.js", exportName: "features" },
+  "cms:install": { path: "./commands/features.js", exportName: "features" },
+  "cms:uninstall": { path: "./commands/features.js", exportName: "features" },
+  "marketing:install": { path: "./commands/features.js", exportName: "features" },
+  "marketing:uninstall": { path: "./commands/features.js", exportName: "features" },
+  "monitoring:install": { path: "./commands/features.js", exportName: "features" },
+  "monitoring:uninstall": { path: "./commands/features.js", exportName: "features" },
+  "realtime:install": { path: "./commands/features.js", exportName: "features" },
+  "realtime:uninstall": { path: "./commands/features.js", exportName: "features" },
+  "queue:install": { path: "./commands/features.js", exportName: "features" },
+  "queue:uninstall": { path: "./commands/features.js", exportName: "features" },
+  fresh: { path: "./commands/fresh.js", exportName: "fresh" },
+  generate: { path: "./commands/generate.js", exportName: "generate" },
+  http: { path: "./commands/http.js", exportName: "http" },
+  install: { path: "./commands/install.js", exportName: "install" },
+  key: { path: "./commands/key.js", exportName: "key" },
+  lint: { path: "./commands/lint.js", exportName: "lint" },
+  list: { path: "./commands/list.js", exportName: "list" },
+  mail: { path: "./commands/mail.js", exportName: "mailCommands" },
+  "mail:preview": { path: "./commands/mail.js", exportName: "mailCommands" },
+  maintenance: { path: "./commands/maintenance.js", exportName: "maintenance" },
+  down: { path: "./commands/maintenance.js", exportName: "maintenance" },
+  up: { path: "./commands/maintenance.js", exportName: "maintenance" },
+  status: { path: "./commands/maintenance.js", exportName: "maintenance" },
+  make: { path: "./commands/make.js", exportName: "make" },
+  migrate: { path: "./commands/migrate.js", exportName: "migrate" },
+  "migrate:fresh": { path: "./commands/migrate.js", exportName: "migrate" },
+  "migrate:switch": { path: "./commands/migrate.js", exportName: "migrate" },
+  "migrate:dns": { path: "./commands/migrate.js", exportName: "migrate" },
+  "migrate:project": { path: "./commands/migrate-project.js", exportName: "migrateProject" },
+  outdated: { path: "./commands/outdated.js", exportName: "outdated" },
+  package: { path: "./commands/package.js", exportName: "packageCommands" },
+  phone: { path: "./commands/phone.js", exportName: "phone" },
+  ports: { path: "./commands/ports.js", exportName: "ports" },
+  prepublish: { path: "./commands/prepublish.js", exportName: "prepublish" },
+  projects: { path: "./commands/projects.js", exportName: "projects" },
+  publish: { path: "./commands/publish.js", exportName: "publish" },
+  "publish:model": { path: "./commands/publish.js", exportName: "publish" },
+  "publish:controller": { path: "./commands/publish.js", exportName: "publish" },
+  "publish:middleware": { path: "./commands/publish.js", exportName: "publish" },
+  "publish:action": { path: "./commands/publish.js", exportName: "publish" },
+  "publish:core": { path: "./commands/publish.js", exportName: "publish" },
+  queue: { path: "./commands/queue.js", exportName: "queue" },
+  release: { path: "./commands/release.js", exportName: "release" },
+  route: { path: "./commands/route.js", exportName: "route" },
+  saas: { path: "./commands/saas.js", exportName: "saas" },
+  schedule: { path: "./commands/schedule.js", exportName: "schedule" },
+  search: { path: "./commands/search.js", exportName: "search" },
+  seed: { path: "./commands/seed.js", exportName: "seed" },
+  "seed:roles": { path: "./commands/seed.js", exportName: "seed" },
+  "roles:seed": { path: "./commands/seed.js", exportName: "seed" },
+  serve: { path: "./commands/serve.js", exportName: "serve" },
+  "serve:api": { path: "./commands/serve.js", exportName: "serveApi" },
+  setup: { path: "./commands/setup.js", exportName: "setup" },
+  share: { path: "./commands/share.js", exportName: "share" },
+  stack: { path: "./commands/stacks.js", exportName: "stacks" },
+  sms: { path: "./commands/sms.js", exportName: "sms" },
+  telemetry: { path: "./commands/telemetry.js", exportName: "telemetryCommand" },
+  test: { path: "./commands/test.js", exportName: "test" },
+  tinker: { path: "./commands/tinker.js", exportName: "tinker" },
+  types: { path: "./commands/types.js", exportName: "types" },
+  undeploy: { path: "./commands/cloud.js", exportName: "cloud" },
+  upgrade: { path: "./commands/upgrade.js", exportName: "upgrade" },
+  version: { path: "./commands/version.js", exportName: "version" }
+}, commandGroups = {
+  minimal: ["version", "help"],
+  development: ["dev", "build", "test", "lint"],
+  database: ["migrate", "seed", "fresh"],
+  scaffolding: ["make", "generate"],
+  deployment: ["deploy", "release", "cloud"],
+  info: ["about", "doctor", "list"]
+}, loadedRegistrars = new WeakMap;
+function loaderKey(loader) {
+  return `${loader.path}#${loader.exportName}`;
+}
+export function markLoaded(buddy, commandName) {
+  const loader = commandRegistry[commandName];
+  if (!loader)
+    return;
+  let set = loadedRegistrars.get(buddy);
+  if (!set) {
+    set = new Set;
+    loadedRegistrars.set(buddy, set);
+  }
+  set.add(loaderKey(loader));
+}
+export async function loadCommand(commandName, buddy) {
+  const loader = commandRegistry[commandName];
+  if (!loader)
+    return !1;
+  let set = loadedRegistrars.get(buddy);
+  if (!set) {
+    set = new Set;
+    loadedRegistrars.set(buddy, set);
+  }
+  const key = loaderKey(loader);
+  if (set.has(key))
+    return !0;
+  set.add(key);
+  try {
+    const commandFunction = (await import(loader.path))[loader.exportName];
+    if (typeof commandFunction === "function") {
+      commandFunction(buddy);
+      return !0;
+    } else
+      return !1;
+  } catch {
+    return !1;
+  }
+}
+export async function loadCommands(commandNames, buddy) {
+  const timeout = (ms) => new Promise((_, reject) => setTimeout(() => reject(Error("timeout")), ms)), seen = new Set, unique = [];
+  for (const name of commandNames) {
+    const loader = commandRegistry[name], key = loader ? `${loader.path}#${loader.exportName}` : `name:${name}`;
+    if (seen.has(key))
+      continue;
+    seen.add(key);
+    unique.push(name);
+  }
+  await Promise.all(unique.map(async (name) => {
+    try {
+      await Promise.race([
+        loadCommand(name, buddy),
+        timeout(5000)
+      ]);
+    } catch {}
+  }));
+}
+export async function loadCommandGroup(groupName, buddy) {
+  const commands = commandGroups[groupName];
+  if (commands)
+    await loadCommands(commands, buddy);
+}
+export async function loadAllCommands(buddy) {
+  const allCommands = Object.keys(commandRegistry);
+  await loadCommands(allCommands, buddy);
+}
+export function getCommandNames() {
+  return Object.keys(commandRegistry);
+}
+export function getCommandsToLoad(args) {
+  const requestedCommand = args[0], isVersionFlag = requestedCommand === "--version" || requestedCommand === "-v", isHelpFlag = requestedCommand === "--help" || requestedCommand === "-h", isHelpWord = requestedCommand === "help";
+  if (isVersionFlag)
+    return ["version"];
+  if (!requestedCommand || isHelpFlag || isHelpWord)
+    return Object.keys(commandRegistry);
+  const baseCommand = requestedCommand.split(":")[0];
+  if (baseCommand === "list")
+    return ["list", ...Object.keys(commandRegistry).filter((k) => k !== "list")];
+  if (commandRegistry[baseCommand])
+    return [baseCommand];
+  if (requestedCommand.includes(":")) {
+    const namespace = baseCommand;
+    if (commandRegistry[namespace])
+      return [namespace];
+  }
+  return Object.keys(commandRegistry);
+}

package/dist/migrators/index.js

@@ -0,0 +1,62 @@
+import { laravelDriver } from "./laravel";
+import { railsDriver } from "./rails";
+export const DRIVERS = {
+  laravel: laravelDriver,
+  rails: railsDriver
+};
+export async function runMigrator(req) {
+  const driver = DRIVERS[req.from];
+  if (!driver)
+    throw Error(`Unknown source framework: ${req.from}. Supported: ${Object.keys(DRIVERS).join(", ")}`);
+  const startedAt = new Date().toISOString(), entries = await driver.migrate(req), finishedAt = new Date().toISOString();
+  return {
+    source: req.source,
+    target: req.target,
+    from: req.from,
+    startedAt,
+    finishedAt,
+    entries
+  };
+}
+export function renderReport(report) {
+  const lines = [];
+  lines.push(`# Migration report \u2014 ${report.from} \u2192 Stacks`);
+  lines.push("");
+  lines.push(`- **Source**: \`${report.source}\``);
+  lines.push(`- **Target**: \`${report.target}\``);
+  lines.push(`- **Started**: ${report.startedAt}`);
+  lines.push(`- **Finished**: ${report.finishedAt}`);
+  lines.push("");
+  const groups = groupEntriesByStatus(report.entries);
+  for (const [status, label] of [
+    ["translated", "Translated"],
+    ["copied", "Copied verbatim"],
+    ["skipped", "Skipped (hand-port required)"],
+    ["failed", "Failed"]
+  ]) {
+    const group = groups[status] ?? [];
+    if (group.length === 0)
+      continue;
+    lines.push(`## ${label} (${group.length})`);
+    lines.push("");
+    for (const e of group) {
+      const arrow = e.target ? ` \u2192 \`${e.target}\`` : "", note = e.note ? ` \u2014 ${e.note}` : "";
+      lines.push(`- \`${e.source}\`${arrow}${note}`);
+    }
+    lines.push("");
+  }
+  lines.push("---");
+  lines.push("");
+  lines.push("Re-run `./buddy migrate:project <name> --from=" + report.from + "` after fixing the source project to refresh emitted files. Translated outputs are overwritten; skipped entries are not.");
+  return lines.join(`
+`);
+}
+function groupEntriesByStatus(entries) {
+  const out = {};
+  for (const e of entries) {
+    if (!out[e.status])
+      out[e.status] = [];
+    out[e.status].push(e);
+  }
+  return out;
+}

package/dist/migrators/laravel/index.js

@@ -0,0 +1,148 @@
+import { existsSync, readdirSync } from "node:fs";
+import { copyFile, mkdir, readFile, writeFile } from "node:fs/promises";
+import { basename, join } from "node:path";
+import { laravelFilenameToStacks, parseLaravelMigration } from "./migrations";
+import { parseLaravelModel } from "./models";
+export const laravelDriver = {
+  name: "laravel",
+  async migrate(req) {
+    const entries = [];
+    entries.push(...await migrateEnv(req));
+    entries.push(...await migrateMigrations(req));
+    entries.push(...await migrateModels(req));
+    entries.push(...summariseDeferred(req));
+    return entries;
+  }
+};
+async function migrateEnv(req) {
+  const out = [];
+  for (const file of [".env", ".env.example"]) {
+    const sourcePath = join(req.source, file);
+    if (!existsSync(sourcePath))
+      continue;
+    const targetPath = join(req.target, file);
+    if (!req.dryRun) {
+      await mkdir(req.target, { recursive: !0 });
+      await copyFile(sourcePath, targetPath);
+    }
+    out.push({
+      source: file,
+      target: file,
+      status: "copied",
+      note: "Laravel-specific keys (BROADCAST_DRIVER, FILESYSTEM_DISK names) may need renaming; Stacks reads APP_*/DB_*/MAIL_* keys as-is."
+    });
+  }
+  return out;
+}
+async function migrateMigrations(req) {
+  const dir = join(req.source, "database", "migrations");
+  if (!existsSync(dir))
+    return [];
+  const files = readdirSync(dir).filter((f) => f.endsWith(".php")).sort(), targetDir = join(req.target, "database", "migrations");
+  if (!req.dryRun)
+    await mkdir(targetDir, { recursive: !0 });
+  const out = [];
+  for (let i = 0;i < files.length; i++) {
+    const file = files[i], rel = `database/migrations/${file}`;
+    try {
+      const body = await readFile(join(dir, file), "utf8"), parsed = parseLaravelMigration(body);
+      if (!parsed) {
+        out.push({
+          source: rel,
+          target: "",
+          status: "skipped",
+          note: "No `Schema::create(...)` block found (likely an alter / drop / data-only migration)."
+        });
+        continue;
+      }
+      const sequence = i + 1, outRel = `database/migrations/${laravelFilenameToStacks(file, sequence, parsed.table)}`;
+      if (!req.dryRun)
+        await writeFile(join(req.target, outRel), parsed.sql);
+      const skippedNote = parsed.skipped.length > 0 ? ` Skipped ${parsed.skipped.length} line(s) inside the create block \u2014 hand-port from the source migration.` : "";
+      out.push({
+        source: rel,
+        target: outRel,
+        status: "translated",
+        note: `CREATE TABLE \`${parsed.table}\` emitted.${skippedNote}`
+      });
+    } catch (err) {
+      out.push({
+        source: rel,
+        target: "",
+        status: "failed",
+        note: `Parse error: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  return out;
+}
+async function migrateModels(req) {
+  const dir = join(req.source, "app", "Models");
+  if (!existsSync(dir))
+    return [];
+  const files = readdirSync(dir).filter((f) => f.endsWith(".php")), targetDir = join(req.target, "app", "Models");
+  if (!req.dryRun)
+    await mkdir(targetDir, { recursive: !0 });
+  const out = [];
+  for (const file of files) {
+    const rel = `app/Models/${file}`;
+    try {
+      const body = await readFile(join(dir, file), "utf8"), parsed = parseLaravelModel(body);
+      if (!parsed) {
+        out.push({
+          source: rel,
+          target: "",
+          status: "skipped",
+          note: "No class declaration found."
+        });
+        continue;
+      }
+      const outRel = `app/Models/${`${parsed.className}.ts`}`;
+      if (!req.dryRun)
+        await writeFile(join(req.target, outRel), parsed.tsSource);
+      const notes = [
+        `Attributes: ${parsed.fillable.length} fillable, ${Object.keys(parsed.casts).length} cast`,
+        parsed.relationships.length > 0 ? `Relationships: ${parsed.relationships.map((r) => `${r.name}(${r.kind})`).join(", ")}` : null,
+        ...parsed.notes
+      ].filter(Boolean).join(" | ");
+      out.push({
+        source: rel,
+        target: outRel,
+        status: "translated",
+        note: notes || `Model ${parsed.className} emitted.`
+      });
+    } catch (err) {
+      out.push({
+        source: rel,
+        target: "",
+        status: "failed",
+        note: `Parse error: ${err instanceof Error ? err.message : String(err)}`
+      });
+    }
+  }
+  return out;
+}
+const DEFERRED_SURFACES = [
+  { path: "routes", note: "routes/web.php + routes/api.php \u2014 port to routes/web.ts + routes/api.ts using the Stacks router DSL." },
+  { path: "app/Http/Controllers", note: "Controllers \u2192 Stacks Actions in app/Actions/. Each controller method maps to one Action file." },
+  { path: "resources/views", note: "Blade templates \u2192 stx components in resources/views/." },
+  { path: "database/seeders", note: "Seeders \u2192 database/seeders/*.ts using Stacks SeederContract." },
+  { path: "app/Console/Commands", note: "Artisan commands \u2192 app/Commands/*.ts in your Stacks project." },
+  { path: "app/Jobs", note: "Queue jobs \u2192 app/Jobs/*.ts; pair with config/queue.ts driver settings." },
+  { path: "composer.json", note: "Dependency map \u2014 Laravel packages don't translate 1:1; the Stacks docs cover the closest @stacksjs/* equivalents." }
+];
+function summariseDeferred(req) {
+  const out = [];
+  for (const surface of DEFERRED_SURFACES) {
+    const sourcePath = join(req.source, surface.path);
+    if (!existsSync(sourcePath))
+      continue;
+    out.push({
+      source: surface.path,
+      target: "",
+      status: "skipped",
+      note: surface.note
+    });
+  }
+  return out;
+}

package/dist/migrators/laravel/migrations.js

@@ -0,0 +1,231 @@
+export function parseLaravelMigration(source) {
+  const createMatch = source.match(/Schema::create\(\s*['"]([a-z0-9_]+)['"]\s*,\s*function\s*\([^)]*\)\s*\{([\s\S]*?)\}\s*\)\s*;/i);
+  if (!createMatch)
+    return null;
+  const table = createMatch[1], body = createMatch[2], skipped = [], columns = [], indexes = [], lines = body.split(`
+`).map((line) => line.trim()).filter((line) => line.length > 0 && !line.startsWith("//") && !line.startsWith("*") && !line.startsWith("/*"));
+  for (const line of lines) {
+    const trimmed = line.replace(/;\s*$/, "");
+    if (!trimmed.startsWith("$table->")) {
+      skipped.push(line);
+      continue;
+    }
+    const parsed = parseColumnLine(trimmed);
+    if (!parsed) {
+      skipped.push(line);
+      continue;
+    }
+    if (parsed.kind === "columns") {
+      columns.push(...parsed.columns);
+      if (parsed.indexes)
+        indexes.push(...parsed.indexes);
+    } else if (parsed.kind === "index")
+      indexes.push(parsed.index);
+    else if (parsed.kind === "skip")
+      skipped.push(line);
+  }
+  const sql = emitCreateTable(table, columns, indexes);
+  return { table, sql, skipped };
+}
+function parseColumnLine(line) {
+  const methodMatch = line.match(/^\$table->([a-zA-Z_]+)\s*\(([^)]*)\)(.*)$/);
+  if (!methodMatch)
+    return null;
+  const method = methodMatch[1], args = methodMatch[2].trim(), rest = methodMatch[3];
+  if (method === "timestamps")
+    return {
+      kind: "columns",
+      columns: [
+        { name: "created_at", type: "DATETIME", nullable: !0, unique: !1, primaryKey: !1, autoIncrement: !1, defaultValue: "CURRENT_TIMESTAMP", index: !1 },
+        { name: "updated_at", type: "DATETIME", nullable: !0, unique: !1, primaryKey: !1, autoIncrement: !1, defaultValue: null, index: !1 }
+      ]
+    };
+  if (method === "softDeletes")
+    return {
+      kind: "columns",
+      columns: [
+        { name: "deleted_at", type: "DATETIME", nullable: !0, unique: !1, primaryKey: !1, autoIncrement: !1, defaultValue: null, index: !1 }
+      ]
+    };
+  if (method === "rememberToken")
+    return {
+      kind: "columns",
+      columns: [
+        { name: "remember_token", type: "TEXT", nullable: !0, unique: !1, primaryKey: !1, autoIncrement: !1, defaultValue: null, index: !1 }
+      ]
+    };
+  if (method === "id" || method === "increments" || method === "bigIncrements")
+    return {
+      kind: "columns",
+      columns: [
+        { name: parseStringArg(args) || "id", type: "INTEGER", nullable: !1, unique: !1, primaryKey: !0, autoIncrement: !0, defaultValue: null, index: !1 }
+      ]
+    };
+  if (method === "index" || method === "unique") {
+    const cols = parseIndexArg(args);
+    if (cols.length === 0)
+      return { kind: "skip" };
+    return {
+      kind: "index",
+      index: { name: "", columns: cols, unique: method === "unique" }
+    };
+  }
+  const columnName = parseStringArg(args);
+  if (!columnName)
+    return null;
+  const sqlType = mapType(method);
+  if (!sqlType)
+    return { kind: "skip" };
+  const column = {
+    name: columnName,
+    type: sqlType,
+    nullable: !1,
+    unique: !1,
+    primaryKey: !1,
+    autoIncrement: !1,
+    defaultValue: null,
+    index: !1
+  };
+  applyModifiers(rest, column);
+  const indexes = [];
+  if (column.unique)
+    indexes.push({ name: "", columns: [columnName], unique: !0 });
+  if (column.index)
+    indexes.push({ name: "", columns: [columnName], unique: !1 });
+  return { kind: "columns", columns: [column], indexes };
+}
+function applyModifiers(rest, column) {
+  const modRegex = /->([a-zA-Z_]+)\s*\(([^)]*)\)/g;
+  let match;
+  while ((match = modRegex.exec(rest)) !== null) {
+    const mod = match[1], args = match[2].trim();
+    switch (mod) {
+      case "nullable":
+        column.nullable = !0;
+        break;
+      case "unique":
+        column.unique = !0;
+        break;
+      case "index":
+        column.index = !0;
+        break;
+      case "default":
+        column.defaultValue = parseDefaultArg(args);
+        break;
+      case "primary":
+        column.primaryKey = !0;
+        break;
+      case "autoIncrement":
+        column.autoIncrement = !0;
+        break;
+      case "unsigned":
+      case "comment":
+      case "after":
+      case "change":
+        break;
+      default:
+        break;
+    }
+  }
+}
+function parseStringArg(args) {
+  const m = args.match(/^['"]([^'"]+)['"]/);
+  return m ? m[1] : null;
+}
+function parseIndexArg(args) {
+  const single = parseStringArg(args);
+  if (single)
+    return [single];
+  const arr = args.match(/\[([^\]]*)\]/);
+  if (!arr)
+    return [];
+  return arr[1].split(",").map((s) => s.trim().replace(/^['"]|['"]$/g, "")).filter(Boolean);
+}
+function parseDefaultArg(args) {
+  const stringMatch = args.match(/^['"]([^'"]*)['"]/);
+  if (stringMatch)
+    return `'${stringMatch[1].replace(/'/g, "''")}'`;
+  const trimmed = args.trim();
+  if (trimmed === "true")
+    return "1";
+  if (trimmed === "false")
+    return "0";
+  if (trimmed === "null")
+    return "NULL";
+  if (/^-?\d+(\.\d+)?$/.test(trimmed))
+    return trimmed;
+  return trimmed;
+}
+const TYPE_MAP = {
+  string: "TEXT",
+  text: "TEXT",
+  mediumText: "TEXT",
+  longText: "TEXT",
+  char: "TEXT",
+  integer: "INTEGER",
+  tinyInteger: "INTEGER",
+  smallInteger: "INTEGER",
+  mediumInteger: "INTEGER",
+  bigInteger: "INTEGER",
+  unsignedBigInteger: "INTEGER",
+  unsignedInteger: "INTEGER",
+  foreignId: "INTEGER",
+  boolean: "INTEGER",
+  date: "DATE",
+  dateTime: "DATETIME",
+  dateTimeTz: "DATETIME",
+  timestamp: "DATETIME",
+  timestampTz: "DATETIME",
+  time: "TIME",
+  timeTz: "TIME",
+  year: "INTEGER",
+  json: "TEXT",
+  jsonb: "TEXT",
+  uuid: "TEXT",
+  ulid: "TEXT",
+  ipAddress: "TEXT",
+  macAddress: "TEXT",
+  float: "REAL",
+  double: "REAL",
+  decimal: "REAL",
+  binary: "BLOB",
+  enum: "TEXT",
+  set: "TEXT"
+};
+function mapType(laravelMethod) {
+  return TYPE_MAP[laravelMethod] ?? null;
+}
+function emitCreateTable(table, columns, indexes) {
+  const lines = [];
+  lines.push(`CREATE TABLE IF NOT EXISTS ${table} (`);
+  const colDefs = columns.map((c) => {
+    const parts = [`  ${c.name} ${c.type}`];
+    if (c.primaryKey)
+      parts.push("PRIMARY KEY");
+    if (c.autoIncrement)
+      parts.push("AUTOINCREMENT");
+    if (!c.nullable && !c.primaryKey)
+      parts.push("NOT NULL");
+    if (c.defaultValue !== null)
+      parts.push(`DEFAULT ${c.defaultValue}`);
+    return parts.join(" ");
+  });
+  lines.push(colDefs.join(`,
+`));
+  lines.push(");");
+  for (const idx of indexes) {
+    const cols = idx.columns.join(", "), indexName = idx.name || `${table}_${idx.columns.join("_")}_${idx.unique ? "unique" : "index"}`, verb = idx.unique ? "CREATE UNIQUE INDEX" : "CREATE INDEX";
+    lines.push(`${verb} IF NOT EXISTS ${indexName} ON ${table}(${cols});`);
+  }
+  return `${lines.join(`
+`)}
+`;
+}
+export function laravelFilenameToStacks(filename, sequence, table) {
+  const padded = String(sequence).padStart(10, "0"), base = filename.toLowerCase();
+  if (base.includes("create_") && base.includes("_table"))
+    return `${padded}-create-${table}-table.sql`;
+  if (base.includes("add_") || base.includes("alter_"))
+    return `${padded}-alter-${table}-migration.sql`;
+  return `${padded}-create-${table}-table.sql`;
+}