@t1mmen/srtd 0.0.0-next-20251227000343

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Timm Stokke
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,363 @@
+# `srtd` 🪄 Supabase Repeatable Template Definitions
+
+
+
+> Live-reloading SQL templates for [Supabase](https://supabase.com) projects. DX supercharged! 🚀
+
+[![NPM Version](https://img.shields.io/npm/v/%40t1mmen%2Fsrtd)](https://www.npmjs.com/package/@t1mmen/srtd)
+[![Downloads](https://img.shields.io/npm/dt/%40t1mmen%2Fsrtd)](https://www.npmjs.com/package/@t1mmen/srtd)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI/CD](https://github.com/t1mmen/srtd/actions/workflows/ci.yml/badge.svg)](https://github.com/t1mmen/srtd/actions/workflows/ci.yml)
+[![codecov](https://codecov.io/gh/t1mmen/srtd/graph/badge.svg?token=CIMAZ55KCJ)](https://codecov.io/gh/t1mmen/srtd)
+
+
+[![video demo](./readme-demo.gif)](./readme-demo.gif)
+
+
+`srtd` enhances the [Supabase](https://supabase.com) DX by adding **live-reloading SQL** from templates into local db.
+
+**Templates act as single-source-of-truth of your database objects**, that `build` to regular SQL migrations; This makes for sane code reviews and functional change history, (e.g `git blame` works as expected).
+
+
+📖 Blog: [Introducing `srtd`: Live-Reloading SQL Templates for Supabase](https://timm.stokke.me/blog/srtd-live-reloading-and-sql-templates-for-supabase)
+
+### Why This Exists 🤔
+
+While building [Timely](https://www.timely.com)'s next-generation [Memory Engine](https://www.timely.com/memory-app) on [Supabase](https://supabase.com), we found ourselves facing two major annoyances:
+
+1. Code reviews were painful - function changes showed up as complete rewrites, `git blame` was useless
+2. Designing and iterating on database changes locally was full of friction, no matter which workflow we tried
+
+I spent [nearly two](https://news.ycombinator.com/item?id=37755076) [years looking](https://news.ycombinator.com/item?id=36007640) for something pre-existing, to no avail. Sufficiently fed up, I paired with [Claude](https://claude.ai) to eliminate these annoyances.
+
+Say hello to `srtd`.
+
+[![screenshot of srtd](./readme-screenshot.png)](./readme-screenshot.png)
+
+## Key Features ✨
+
+- **Live Reload**: Changes to your SQL templates instantly update your local database
+- **Templates as source of truth**: Templates are the source of (non-mutable) database objects
+- **Just SQL**: Templates as just SQL, and `build` to standard [Supabase](https://supabase.com) migrations when you're ready to ship
+- **Sane code reviews**: Templates evolve like regular code, with diffs in PR's working `git blame`.
+- **Developer Friendly**: Interactive CLI with visual feedback for all operations.
+
+Built specifically for projects using the standard [Supabase](https://supabase.com) stack (but probably works alright for other Postgres-based projects, too).
+
+## Quick Start 🚀
+
+### Requirements
+
+- Node.js v20.18.1 or higher
+- [Supabase](https://supabase.com) project initialized (in `/supabase`).
+
+### Installation
+
+
+```bash
+# Global installation
+npm install -g @t1mmen/srtd
+
+# Project installation
+npm install --save-dev @t1mmen/srtd
+
+# Or run directly
+npx @t1mmen/srtd
+```
+
+### Setup
+
+```bash
+cd your-supabase-project
+npx @t1mmen/srtd init # Creates srtd.config.json, not required
+```
+
+### Create Your First Template
+
+Create `supabase/migrations-templates/my_function.sql`:
+
+```sql
+DROP FUNCTION IF EXISTS public.my_function; -- Makes it easier to change args later
+CREATE FUNCTION my_function()
+RETURNS void AS $$
+BEGIN
+  -- Your function logic here
+END;
+$$ LANGUAGE plpgsql;
+```
+
+### Development Workflow
+
+1. Start watch mode:
+```bash
+npx @t1mmen/srtd watch  # Changes auto-apply to local database
+```
+
+2. When ready to deploy:
+```bash
+npx @t1mmen/srtd build     # Creates timestamped migration file
+supabase migration up      # Apply using Supabase CLI
+```
+
+> [!TIP]
+> To reduce noise in PR's, consider adding `supabase/migrations/*srtd*.sql linguist-generated=true` to your [`.gitattributes` file.](https://docs.github.com/en/repositories/working-with-files/managing-files/customizing-how-changed-files-appear-on-github) (unless you manually edit the generated files)
+
+
+## The Power of Templates 💪
+
+Without templates, the smallest change to a function would show up as a complete rewrite in your version control system. With templates, the diff is clear and concise.
+
+
+### Perfect For 🎯
+
+✅ Database functions:
+```diff
+  -- Event notifications
+  DROP FUNCTION IF EXISTS notify_changes;
+  CREATE FUNCTION notify_changes()
+  RETURNS trigger AS $$
+  BEGIN
+    PERFORM pg_notify(
+      'changes',
+      json_build_object('table', TG_TABLE_NAME, 'id', NEW.id)::text
+    );
++   RAISE NOTICE 'Notified changes for %', TG_TABLE_NAME; -- Debug logging
+    RETURN NEW;
+  END;
+  $$ LANGUAGE plpgsql;
+```
+
+✅ Row-Level Security (RLS):
+```diff
+  -- Replace/update policies safely
+  DROP POLICY IF EXISTS "workspace_access" ON resources;
+  CREATE POLICY "workspace_access" ON resources
+    USING (workspace_id IN (
+      SELECT id FROM workspaces
+      WHERE organization_id = auth.organization_id()
++       AND auth.user_role() NOT IN ('pending')
+    ));
+```
+
+✅ Views for data abstraction:
+```diff
+  CREATE OR REPLACE VIEW active_subscriptions AS
+  SELECT
+    s.*,
+    p.name as plan_name,
+    p.features
+  FROM subscriptions s
+  JOIN plans p ON p.id = s.plan_id
+-  WHERE s.status = 'active';
++  WHERE s.status = 'active'
++    AND s.expires_at > CURRENT_TIMESTAMP;
+```
+
+✅ Roles and Permissions:
+```diff
+  -- Revoke all first for clean state
+  REVOKE ALL ON ALL TABLES IN SCHEMA public FROM public;
+
+  -- Grant specific access
+  GRANT USAGE ON SCHEMA public TO authenticated;
+  GRANT SELECT ON ALL TABLES IN SCHEMA public TO authenticated;
++ GRANT SELECT, INSERT, UPDATE, DELETE ON ALL TABLES IN SCHEMA public TO admin;
+```
+
+✅ Safe Type Extensions:
+```diff
+ DO $$
+ BEGIN
+   -- Add new enum values idempotently
+   IF NOT EXISTS (SELECT 1 FROM pg_type WHERE typname = 'notification_type') THEN
+     CREATE TYPE notification_type AS ENUM ('email', 'sms');
+   END IF;
+
+   -- Extend existing enum safely
+   ALTER TYPE notification_type ADD VALUE IF NOT EXISTS 'push';
+   ALTER TYPE notification_type ADD VALUE IF NOT EXISTS 'pusher';
+   ALTER TYPE notification_type ADD VALUE IF NOT EXISTS 'webhook';
++  ALTER TYPE notification_type ADD VALUE IF NOT EXISTS 'whatsapp';
+ END $$;
+```
+
+✅ Triggers
+```diff
+ DROP TRIGGER IF EXISTS on_new_user ON auth.users;
+ DROP FUNCTION IF EXISTS public.setup_new_user;
+
+ CREATE FUNCTION public.setup_new_user() RETURNS TRIGGER LANGUAGE plpgsql SECURITY DEFINER
+ SET search_path = public AS $$
+ BEGIN
+   -- Existing logic for new users
+
++  -- Your new changes go here..
+ END;
+ $$;
+
+ CREATE TRIGGER on_new_user AFTER INSERT ON auth.users FOR EACH ROW EXECUTE PROCEDURE public.setup_new_user ();
+```
+
+> [!TIP]
+> You don't need to specifying parameters in drop functions. E.g `DROP FUNCTION IF EXISTS public.my_function;`. This ensures you don't end up with multiple functions with the same name, but different parameters.
+
+### Not Recommended For:
+* ❌ Table structures
+* ❌ Indexes
+* ❌ Data modifications
+* ❌ Non-idempotent operations
+
+Use regular [Supabase](https://supabase.com) migrations for these cases.
+
+
+## Commands 🎮
+
+### Interactive Mode
+
+Running `npx @t1mmen/srtd` without arguments opens an interactive menu. All commands can also be run directly:
+
+- 👀 `srtd watch` - Watch and auto-apply changes
+- 🏗️  `srtd build [--force] [--bundle]` - Generate migrations from templates
+- ▶️  `srtd apply [--force]` - Apply templates directly to local database
+- ✍️  `srtd register [file.sql...]` - Mark templates as already built
+- 🚀  `srtd promote - [file.sql ...]` - Promote WIP template to buildable templates
+- 🧹 `srtd clear` - Clear build logs or reset configuration
+
+> [!IMPORTANT]
+> `watch` and `apply` commands modify your local database directly and don't clean up after themselves. Use with caution!
+
+## Configuration 📝
+
+`srtd.config.json` can be created with `init` command. It is not necessary, if the defaults suit your needs.
+
+```jsonc
+{
+  // Prevents building templates with this extension
+  "wipIndicator": ".wip",
+
+  // Migration file naming: 20211001000000_srtd-my_function.sql
+  "migrationPrefix": "srtd",
+
+  // Template discovery
+  "filter": "**/*.sql",
+
+  // Migration file comments
+  "banner": "You very likely **DO NOT** want to manually edit this generated file.",
+  "footer": "",
+
+  // Wrap migrations in transaction
+  "wrapInTransaction": true,
+
+  // File paths
+  "templateDir": "supabase/migrations-templates",
+  "migrationDir": "supabase/migrations",
+  "buildLog": "supabase/migrations-templates/.buildlog.json",
+  "localBuildLog": "supabase/migrations-templates/.buildlog.local.json",
+
+  // Database connection
+  "pgConnection": "postgresql://postgres:postgres@localhost:54322/postgres"
+}
+```
+
+## Other Features 🔧
+
+### Work in Progress Templates
+
+Add `.wip.sql` extension to prevent migration generation:
+```bash
+my_function.wip.sql  # Only applied locally, never built
+```
+
+Make a WIP template buildable as migration by renaming it, or using the `promote` command:
+```bash
+npx @t1mmen/srtd promote my_function.wip.sql
+```
+
+### Register Existing Objects
+
+Registering a template is useful when you're creating templates for what is already in your database. This avoids generating migrations on `build` (until they're changed)
+
+```bash
+# Register specific template
+npx @t1mmen/srtd register my_function.sql another_fn.sql
+
+# Interactive multi-select UI
+npx @t1mmen/srtd register
+```
+
+This can be useful when setting up `srtd` for an existing project, where you may have hundreds of existing functions, views, etc that you want as templates, but don't want to generate migrations until changed later.
+
+### Template State Management
+
+The state of templates are stored to..
+
+- [`.buildlog.json`](https://github.com/t1mmen/srtd/blob/main/supabase/migrations-templates/.srtd.buildlog.json) - Migration build state (commit this)
+- `.buildlog.local.json` - Local database state (add to `.gitignore`)
+
+This helps `srtd` identify when templates are changed, to only `build` (as migrations) or `apply`  the necessary changes (directly to local db).
+
+## Development 🛠️
+
+### Local Setup
+
+```bash
+# Clone and install
+git clone https://github.com/stokke/srtd.git
+cd srtd
+npm install
+
+# Development
+npm run dev     # Watch mode
+npm test        # Run tests
+npm start       # Run CLI
+npm start:link  # Build, npm link, and run CLI
+
+# Quality Checks
+npm run typecheck       # Type checking
+npm run lint            # Lint and fix
+npm run format          # Format code
+npm run test:coverage   # Test coverage
+```
+
+## Contributing 🤝
+
+While feature-complete for our needs, we welcome:
+
+- 🐛 Bug fixes and reliability improvements
+- 📚 Documentation improvements
+- ✅ Test coverage enhancements
+- ⚡️ Performance optimizations
+
+### Contribution Process
+
+1. Create a [changeset](https://github.com/changesets/changesets) (`npm run changeset`)
+2. Ensure tests pass (`npm test`)
+3. Follow existing code style
+4. Update documentation
+
+Note: New features are evaluated based on alignment with project scope.
+
+## Built With 🛠️
+
+### CLI
+- [Commander.js](https://github.com/tj/commander.js) - CLI framework
+- [Inquirer](https://github.com/SBoudrias/Inquirer.js) - Interactive prompts
+- [Ora](https://github.com/sindresorhus/ora) - Terminal spinners
+- [Chalk](https://github.com/chalk/chalk) - Terminal styling
+- [Figures](https://github.com/sindresorhus/figures) - Unicode symbols
+
+### Core
+- [Chokidar](https://github.com/paulmillr/chokidar) - File watcher
+- [Zod](https://zod.dev/) - Schema validation
+- [update-notifier](https://github.com/sindresorhus/update-notifier) - Version checks
+
+
+## License
+
+MIT License - see [LICENSE](LICENSE) file.
+
+---
+
+Made with 🪄 by [Timm Stokke](https://timm.stokke.me) & [Claude Sonnet](https://claude.ai)
+
+[!["Buy Me A Coffee"](https://www.buymeacoffee.com/assets/img/custom_images/orange_img.png)](https://www.buymeacoffee.com/t1mmen)

package/dist/cli.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import { Command } from 'commander';
+import updateNotifier from 'update-notifier';
+import packageJson from '../package.json' with { type: 'json' };
+// Check for test environment
+const isTestMode = process.env.SRTD_TEST_MODE === 'true';
+const nonInteractiveFlag = process.argv.includes('--non-interactive');
+// Only show update notifications in non-test mode
+if (!isTestMode) {
+    updateNotifier({ pkg: packageJson }).notify();
+}
+import { applyCommand } from './commands/apply.js';
+import { buildCommand } from './commands/build.js';
+import { clearCommand } from './commands/clear.js';
+// Import commands
+import { initCommand } from './commands/init.js';
+import { showMenu } from './commands/menu.js';
+import { promoteCommand } from './commands/promote.js';
+import { registerCommand } from './commands/register.js';
+import { watchCommand } from './commands/watch.js';
+// Create the main program
+const program = new Command();
+program
+    .name('srtd')
+    .description('Supabase Repeatable Template Definitions - Live-reloading SQL templates')
+    .version(packageJson.version);
+// Register all commands
+program.addCommand(initCommand);
+program.addCommand(applyCommand);
+program.addCommand(buildCommand);
+program.addCommand(clearCommand);
+program.addCommand(promoteCommand);
+program.addCommand(registerCommand);
+program.addCommand(watchCommand);
+// Check if no arguments were provided (flags like --version should still be parsed)
+const args = process.argv.slice(2);
+const hasArgs = args.length > 0;
+// If no args provided and we're in TTY, show interactive menu
+if (!hasArgs && process.stdin.isTTY && !isTestMode && !nonInteractiveFlag) {
+    await showMenu();
+}
+else {
+    // Parse command line arguments (Commander handles --help, --version, and commands)
+    await program.parseAsync(process.argv);
+}
+// For testing purposes, ensure process exits cleanly
+if (isTestMode || nonInteractiveFlag) {
+    process.exit(0);
+}
+//# sourceMappingURL=cli.js.map

package/dist/cli.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cli.js","sourceRoot":"","sources":["../src/cli.ts"],"names":[],"mappings":";AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,cAAc,MAAM,iBAAiB,CAAC;AAC7C,OAAO,WAAW,MAAM,iBAAiB,CAAC,OAAO,IAAI,EAAE,MAAM,EAAE,CAAC;AAEhE,6BAA6B;AAC7B,MAAM,UAAU,GAAG,OAAO,CAAC,GAAG,CAAC,cAAc,KAAK,MAAM,CAAC;AACzD,MAAM,kBAAkB,GAAG,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,mBAAmB,CAAC,CAAC;AAEtE,kDAAkD;AAClD,IAAI,CAAC,UAAU,EAAE,CAAC;IAChB,cAAc,CAAC,EAAE,GAAG,EAAE,WAAW,EAAE,CAAC,CAAC,MAAM,EAAE,CAAC;AAChD,CAAC;AAED,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AACnD,kBAAkB;AAClB,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAC;AACjD,OAAO,EAAE,QAAQ,EAAE,MAAM,oBAAoB,CAAC;AAC9C,OAAO,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AACvD,OAAO,EAAE,eAAe,EAAE,MAAM,wBAAwB,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,qBAAqB,CAAC;AAEnD,0BAA0B;AAC1B,MAAM,OAAO,GAAG,IAAI,OAAO,EAAE,CAAC;AAE9B,OAAO;KACJ,IAAI,CAAC,MAAM,CAAC;KACZ,WAAW,CAAC,yEAAyE,CAAC;KACtF,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;AAEhC,wBAAwB;AACxB,OAAO,CAAC,UAAU,CAAC,WAAW,CAAC,CAAC;AAChC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AACjC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AACjC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AACjC,OAAO,CAAC,UAAU,CAAC,cAAc,CAAC,CAAC;AACnC,OAAO,CAAC,UAAU,CAAC,eAAe,CAAC,CAAC;AACpC,OAAO,CAAC,UAAU,CAAC,YAAY,CAAC,CAAC;AAEjC,oFAAoF;AACpF,MAAM,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;AACnC,MAAM,OAAO,GAAG,IAAI,CAAC,MAAM,GAAG,CAAC,CAAC;AAEhC,8DAA8D;AAC9D,IAAI,CAAC,OAAO,IAAI,OAAO,CAAC,KAAK,CAAC,KAAK,IAAI,CAAC,UAAU,IAAI,CAAC,kBAAkB,EAAE,CAAC;IAC1E,MAAM,QAAQ,EAAE,CAAC;AACnB,CAAC;KAAM,CAAC;IACN,mFAAmF;IACnF,MAAM,OAAO,CAAC,UAAU,CAAC,OAAO,CAAC,IAAI,CAAC,CAAC;AACzC,CAAC;AAED,qDAAqD;AACrD,IAAI,UAAU,IAAI,kBAAkB,EAAE,CAAC;IACrC,OAAO,CAAC,IAAI,CAAC,CAAC,CAAC,CAAC;AAClB,CAAC"}

package/dist/commands/apply.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const applyCommand: Command;

package/dist/commands/apply.js

@@ -0,0 +1,105 @@
+var __addDisposableResource = (this && this.__addDisposableResource) || function (env, value, async) {
+    if (value !== null && value !== void 0) {
+        if (typeof value !== "object" && typeof value !== "function") throw new TypeError("Object expected.");
+        var dispose, inner;
+        if (async) {
+            if (!Symbol.asyncDispose) throw new TypeError("Symbol.asyncDispose is not defined.");
+            dispose = value[Symbol.asyncDispose];
+        }
+        if (dispose === void 0) {
+            if (!Symbol.dispose) throw new TypeError("Symbol.dispose is not defined.");
+            dispose = value[Symbol.dispose];
+            if (async) inner = dispose;
+        }
+        if (typeof dispose !== "function") throw new TypeError("Object not disposable.");
+        if (inner) dispose = function() { try { inner.call(this); } catch (e) { return Promise.reject(e); } };
+        env.stack.push({ value: value, dispose: dispose, async: async });
+    }
+    else if (async) {
+        env.stack.push({ async: true });
+    }
+    return value;
+};
+var __disposeResources = (this && this.__disposeResources) || (function (SuppressedError) {
+    return function (env) {
+        function fail(e) {
+            env.error = env.hasError ? new SuppressedError(e, env.error, "An error was suppressed during disposal.") : e;
+            env.hasError = true;
+        }
+        var r, s = 0;
+        function next() {
+            while (r = env.stack.pop()) {
+                try {
+                    if (!r.async && s === 1) return s = 0, env.stack.push(r), Promise.resolve().then(next);
+                    if (r.dispose) {
+                        var result = r.dispose.call(r.value);
+                        if (r.async) return s |= 2, Promise.resolve(result).then(next, function(e) { fail(e); return next(); });
+                    }
+                    else s |= 1;
+                }
+                catch (e) {
+                    fail(e);
+                }
+            }
+            if (s === 1) return env.hasError ? Promise.reject(env.error) : Promise.resolve();
+            if (env.hasError) throw env.error;
+        }
+        return next();
+    };
+})(typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
+    var e = new Error(message);
+    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
+});
+import chalk from 'chalk';
+// src/commands/apply.ts
+import { Command } from 'commander';
+import figures from 'figures';
+import { Orchestrator } from '../services/Orchestrator.js';
+import { createSpinner, renderBranding, renderResults } from '../ui/index.js';
+import { getConfig } from '../utils/config.js';
+import { findProjectRoot } from '../utils/findProjectRoot.js';
+import { getErrorMessage } from '../utils/getErrorMessage.js';
+export const applyCommand = new Command('apply')
+    .description('Apply built migrations to the database')
+    .option('-f, --force', 'Force apply of all templates, irrespective of changes')
+    .action(async (options) => {
+    let exitCode = 0;
+    try {
+        const env_1 = { stack: [], error: void 0, hasError: false };
+        try {
+            await renderBranding({ subtitle: 'Apply migrations' });
+            const spinner = createSpinner('Applying templates...').start();
+            // Initialize Orchestrator
+            const projectRoot = await findProjectRoot();
+            const config = await getConfig(projectRoot);
+            const orchestrator = __addDisposableResource(env_1, await Orchestrator.create(projectRoot, config, { silent: true }), true);
+            // Execute apply operation
+            const result = await orchestrator.apply({
+                force: options.force,
+                silent: true,
+            });
+            spinner.stop();
+            // Show results
+            renderResults(result, { showApply: true });
+            exitCode = result.errors.length > 0 ? 1 : 0;
+        }
+        catch (e_1) {
+            env_1.error = e_1;
+            env_1.hasError = true;
+        }
+        finally {
+            const result_1 = __disposeResources(env_1);
+            if (result_1)
+                await result_1;
+        }
+    }
+    catch (error) {
+        console.log();
+        console.log(chalk.red(`${figures.cross} Error applying templates:`));
+        console.log(chalk.red(getErrorMessage(error)));
+        exitCode = 1;
+    }
+    // Exit AFTER the await using block has completed, ensuring dispose() runs
+    process.exit(exitCode);
+});
+//# sourceMappingURL=apply.js.map

package/dist/commands/apply.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply.js","sourceRoot":"","sources":["../../src/commands/apply.ts"],"names":[],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA,OAAO,KAAK,MAAM,OAAO,CAAC;AAC1B,wBAAwB;AACxB,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AACpC,OAAO,OAAO,MAAM,SAAS,CAAC;AAC9B,OAAO,EAAE,YAAY,EAAE,MAAM,6BAA6B,CAAC;AAE3D,OAAO,EAAE,aAAa,EAAE,cAAc,EAAE,aAAa,EAAE,MAAM,gBAAgB,CAAC;AAC9E,OAAO,EAAE,SAAS,EAAE,MAAM,oBAAoB,CAAC;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAE9D,MAAM,CAAC,MAAM,YAAY,GAAG,IAAI,OAAO,CAAC,OAAO,CAAC;KAC7C,WAAW,CAAC,wCAAwC,CAAC;KACrD,MAAM,CAAC,aAAa,EAAE,uDAAuD,CAAC;KAC9E,MAAM,CAAC,KAAK,EAAE,OAA4B,EAAE,EAAE;IAC7C,IAAI,QAAQ,GAAG,CAAC,CAAC;IAEjB,IAAI,CAAC;;;YACH,MAAM,cAAc,CAAC,EAAE,QAAQ,EAAE,kBAAkB,EAAE,CAAC,CAAC;YAEvD,MAAM,OAAO,GAAG,aAAa,CAAC,uBAAuB,CAAC,CAAC,KAAK,EAAE,CAAC;YAE/D,0BAA0B;YAC1B,MAAM,WAAW,GAAG,MAAM,eAAe,EAAE,CAAC;YAC5C,MAAM,MAAM,GAAG,MAAM,SAAS,CAAC,WAAW,CAAC,CAAC;YAC5C,MAAY,YAAY,kCAAG,MAAM,YAAY,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,EAAE,EAAE,MAAM,EAAE,IAAI,EAAE,CAAC,OAAA,CAAC;YAE5F,0BAA0B;YAC1B,MAAM,MAAM,GAA4B,MAAM,YAAY,CAAC,KAAK,CAAC;gBAC/D,KAAK,EAAE,OAAO,CAAC,KAAK;gBACpB,MAAM,EAAE,IAAI;aACb,CAAC,CAAC;YAEH,OAAO,CAAC,IAAI,EAAE,CAAC;YAEf,eAAe;YACf,aAAa,CAAC,MAAM,EAAE,EAAE,SAAS,EAAE,IAAI,EAAE,CAAC,CAAC;YAE3C,QAAQ,GAAG,MAAM,CAAC,MAAM,CAAC,MAAM,GAAG,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC;;;;;;;;;;;KAC7C;IAAC,OAAO,KAAK,EAAE,CAAC;QACf,OAAO,CAAC,GAAG,EAAE,CAAC;QACd,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,GAAG,OAAO,CAAC,KAAK,4BAA4B,CAAC,CAAC,CAAC;QACrE,OAAO,CAAC,GAAG,CAAC,KAAK,CAAC,GAAG,CAAC,eAAe,CAAC,KAAK,CAAC,CAAC,CAAC,CAAC;QAC/C,QAAQ,GAAG,CAAC,CAAC;IACf,CAAC;IAED,0EAA0E;IAC1E,OAAO,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC;AACzB,CAAC,CAAC,CAAC"}

package/dist/commands/build.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare const buildCommand: Command;