gemstack 0.3.3 → 0.3.4

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 594ad3149a7e3fec2988cc9e4aeb71c5be12d4ac5085d59f106fc08daf996f31
-  data.tar.gz: cb928670277794edc81566287b5bab7943d74fe5277e3e7151ea20877f290ecd
+  metadata.gz: 3aad267b7791a6ed292930136454e90238f3ccacb61ac93fcf9e9cbd4d13a1e2
+  data.tar.gz: d2a196ec3a4cf3fc652a7f8eba101ed02b48ddba87d53ed079835680ba65f890
 SHA512:
-  metadata.gz: 4e7b4bd185326403d60d0f4cf28bb449b60c75e322a110c942ce973e18438b487ff6992f471a6306a748bee879eefec67e6b4e71c753e0285363cfa2d9ec7491
-  data.tar.gz: 7378352448b0ab14ce174b67470f351f53ee87b1f649d2918155519b10f4b729513cdbbaf8d4ddce497ac72ef8fa8cf86607ec9e29f245fc78313ee143b56f94
+  metadata.gz: cab7c1fa05b4d071574044a98df461ccfdcb3050df12927ebf780c5b45a8b3eaa649b1fbb089e217986efc86b5aa35131dcfea4bbf5ca4491f6c17ec65f991bd
+  data.tar.gz: 4dd5583fd43c3b2f750748e8d754c313d10089eeab9ab0ad0245999a4e7790a9db58eb151065414401505ba243ea060074712d17ac36a146cd4976089fffd393

data/lib/gemstack/cli/add_next_steps.rb

@@ -0,0 +1,13 @@
+# frozen_string_literal: true
+
+module GemStack
+  module AddNextSteps
+    STEPS = {
+      "realtime" => "Next: declare channels in config/channels.rb, then GemStack.broadcast(...) — see docs/realtime.md",
+      "auth" => "Next: gemstack db:migrate · open http://localhost:3000/signup · " \
+                "`before :require_login` in controllers — see docs/authentication.md",
+      "storage" => "Next: uploadFile(file) from frontend/lib/upload.ts · production: STORAGE_SERVICE=s3, S3_BUCKET " \
+                   "— see docs/storage.md"
+    }.freeze
+  end
+end

data/lib/gemstack/cli/controller_generator.rb

@@ -27,12 +27,15 @@ module GemStack
       end
 
       def run
+        @manifest = GenerationManifest.new(@root)
         template_files("controller", override_root: @root).each do |rel, source|
           target = File.join(@root, rel.delete_suffix(".tt").gsub("%file_name%", file_name))
-          write(target, render(File.read(source), source))
+          write_tracked(target, render(File.read(source, encoding: "UTF-8"), source), owner: "controller:#{file_name}")
         end
         add_routes
         self
+      ensure
+        @manifest&.save
       end
 
       def route_for(action)
@@ -60,12 +63,14 @@ module GemStack
         path = File.join(@root, "config/routes.rb")
         return status("skip", path, "not found — add routes manually") unless File.file?(path)
 
-        content = File.read(path)
+        @manifest.absolute("config/routes.rb")
+        content = File.read(path, encoding: "UTF-8")
         lines = actions.map { |action| route_line(action) }.reject { |line| content.include?(line) }
         return status("identical", path) if lines.empty?
         return status("skip", path, "no `GemStack.routes do` block found") unless content.match?(ROUTES_BLOCK)
 
         File.write(path, content.sub(ROUTES_BLOCK) { |open| open + lines.map { |l| "  #{l}\n" }.join })
+        lines.each { |line| @manifest.record_route("  #{line}\n", owner: "controller:#{file_name}") }
         status("route", path, lines.join("; "))
       end
     end

data/lib/gemstack/cli/destroy_generator.rb

@@ -0,0 +1,276 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module GemStack
+  class CLI < Thor
+    # Plans the complete operation before changing anything. Only migrations
+    # confirmed pending in the selected environment are eligible for removal.
+    class DestroyGenerator < Generator
+      KINDS = %w[model controller resource].freeze
+      SHARED = (Generator::BASE_CLASSES.values + %w[
+        app/controllers/application_controller.rb test/test_helper.rb
+        frontend/lib/format.ts frontend/lib/gemstack/client.ts
+        frontend/app/layout.tsx frontend/app/providers.tsx frontend/app/globals.css
+      ]).freeze
+
+      def self.configure(cli)
+        cli.method_option :dry_run, type: :boolean, default: false, desc: "Preview without changing files or contracts"
+        cli.method_option :yes, type: :boolean, default: false, desc: "Confirm removal without an interactive prompt"
+        cli.method_option :force, type: :boolean, default: false, desc: "Allow removing modified, tracked files"
+        cli.method_option :remove_migrations, type: :boolean, default: false,
+                                              desc: "Remove pending migrations even if committed to Git"
+        cli.method_option :skip_contract, type: :boolean, default: false, desc: "Don't regenerate the API contract"
+      end
+
+      def self.invoke(kind, name, cli:)
+        options = cli.options
+        root = Project.root!
+        removal = new(
+          kind,
+          name,
+          root: root,
+          dry_run: options[:dry_run],
+          force: options[:force],
+          remove_migrations: options[:remove_migrations],
+          environment: options[:environment]
+        )
+        removal.run { options[:yes] || confirm?(cli) }
+        yield root if removal.changed? && !options[:skip_contract]
+      end
+
+      def self.confirm?(cli)
+        raise Thor::Error, "Non-interactive removal requires --yes. Preview with --dry-run first." unless $stdin.tty?
+
+        %w[y yes].include?(cli.ask("Remove the listed generated files and routes? [y/N]").strip.downcase)
+      end
+
+      def initialize(kind, name, root:, dry_run: false, force: false, remove_migrations: false,
+                     output: $stdout, environment: nil)
+        super(output: output, force: force)
+        unless KINDS.include?(kind) && name && !name.empty?
+          raise Thor::Error, "Usage: gemstack destroy model|controller|resource NAME"
+        end
+
+        @root = File.expand_path(root)
+        @kind = kind
+        @dry_run = dry_run
+        @remove_migrations = remove_migrations
+        @owners = owners_for(name)
+        @manifest = GenerationManifest.new(@root)
+        @environment = environment || ENV.fetch("GEMSTACK_ENV", "development")
+        @migration_status = MigrationStatus.new(@root, environment: @environment)
+        @migration_git_status = MigrationGitStatus.new(@root)
+        @changed = false
+      end
+
+      def changed? = @changed
+
+      def run
+        plan!
+        preview
+        raise Thor::Error, "Nothing removed:\n  #{@conflicts.join("\n  ")}" unless @conflicts.empty?
+        return self if @dry_run || (@files.empty? && @routes.empty?)
+
+        if block_given? && !yield
+          @output.puts("Cancelled; no files changed.")
+          return self
+        end
+
+        verify_snapshot!
+        apply
+        self
+      end
+
+      private
+
+      def owners_for(name)
+        if @kind == "controller"
+          controller = ControllerGenerator.new(name, [], root: @root)
+          return ["controller:#{controller.file_name}"]
+        end
+
+        @spec = ResourceSpec.new(name)
+        owners = ["model:#{@spec.file_name}"]
+        owners += ["controller:#{@spec.plural}", "resource:#{@spec.file_name}"] if @kind == "resource"
+        owners
+      end
+
+      def plan!
+        @conflicts = []
+        selected = @manifest.files.select { |_, entry| @owners.include?(entry["owner"]) }
+        @migrations, @files = selected.partition { |path, _| path.start_with?("db/migrations/") }.map(&:to_h)
+        @routes = @manifest.routes.select { |entry| @owners.include?(entry["owner"]) }
+        @snapshots = {}
+        plan_migrations
+        @files.each { |path, entry| check_file(path, entry) }
+        plan_routes
+        check_dependencies if @spec && @files.key?("app/models/#{@spec.file_name}.rb")
+      end
+
+      def check_file(path, entry)
+        if SHARED.include?(path) || !path.start_with?("app/", "test/", "frontend/", "db/migrations/")
+          raise Thor::Error, "Refusing to remove shared or unsupported path: #{path}"
+        end
+
+        absolute = @manifest.absolute(path)
+        raise Thor::Error, "Expected a generated file: #{path}" if File.exist?(absolute) && !File.file?(absolute)
+
+        digest = File.file?(absolute) ? Digest::SHA256.file(absolute).hexdigest : nil
+        @snapshots[path] = digest
+        return unless digest && digest != entry["sha256"] && !@force
+
+        @conflicts << "Modified file: #{path} (review it, then use --force to remove it explicitly)"
+      end
+
+      def plan_migrations
+        return if @migrations.empty?
+
+        @applied = @migration_status.applied
+        @pending = @migrations.reject { |path, _| @applied.nil? || @applied.include?(File.basename(path)) }
+        @migration_reasons = {}
+        @auto_removed_migrations = {}
+
+        @migrations.each do |path, entry|
+          reason = migration_retention_reason(path)
+          if reason
+            @migration_reasons[path] = reason
+          else
+            @files[path] = entry
+            @auto_removed_migrations[path] = entry unless @remove_migrations
+          end
+        end
+
+        @migrations = @migrations.select { |path, _| @migration_reasons.key?(path) }
+      end
+
+      def migration_retention_reason(path)
+        return "database state unknown" if @applied.nil?
+        return "already applied" if @applied.include?(File.basename(path))
+        return if @remove_migrations
+
+        case @migration_git_status.committed(path)
+        when true then "pending but committed to Git; use --remove-migrations to remove"
+        when nil then "pending but Git state is unknown; use --remove-migrations to remove"
+        end
+      end
+
+      def plan_routes
+        path = @manifest.absolute("config/routes.rb")
+        @route_content = File.file?(path) ? File.read(path, encoding: "UTF-8") : ""
+        @route_after = @route_content.dup
+        @routes.each do |entry|
+          line = entry.fetch("line")
+          unless @route_content.lines.count(line) == 1
+            @conflicts << "Generated route was edited, removed or duplicated: #{line.strip.inspect}; restore it first"
+            next
+          end
+
+          @route_after = @route_after.lines.reject { |candidate| candidate == line }.join
+        end
+        check_remaining_routes
+      end
+
+      def check_remaining_routes
+        controllers = @files.keys.filter_map do |path|
+          path.delete_prefix("app/controllers/").delete_suffix("_controller.rb") if
+            path.start_with?("app/controllers/") && path.end_with?("_controller.rb")
+        end
+        tokens = Ripper.lex(@route_after).reject do |_, type, _, _|
+          %i[on_sp on_ignored_nl on_nl on_comment].include?(type)
+        end
+        controllers.each do |controller|
+          target = tokens.any? { |_, type, text, _| type == :on_tstring_content && text.start_with?("#{controller}#") }
+          resource = resource_route?(tokens, controller)
+          @conflicts << "Remaining route to #{controller}: config/routes.rb (remove it manually)" if target || resource
+        end
+      end
+
+      def resource_route?(tokens, controller)
+        tokens.each_cons(3).any? do |first, second, third|
+          first[1] == :on_ident && %w[resources resource].include?(first[2]) && second[1] == :on_symbeg &&
+            third[2] == controller.split("/").last
+        end
+      end
+
+      # Conservative checks for direct Ruby constants and association symbols.
+      # Dynamic references and application-specific frontend imports still need
+      # review; destroy never rewrites application business logic.
+      def check_dependencies
+        Dir.glob(File.join(@root, "app/**/*.rb")).each do |absolute|
+          relative = Pathname.new(absolute).relative_path_from(Pathname.new(@root)).to_s
+          next if @files.key?(relative)
+
+          @manifest.absolute(relative)
+          tokens = Ripper.lex(File.read(absolute, encoding: "UTF-8"))
+          constant = tokens.any? { |_, type, text, _| type == :on_const && text == @spec.class_name }
+          association = tokens.each_cons(2).any? do |left, right|
+            left[1] == :on_symbeg && %i[on_ident on_const].include?(right[1]) &&
+              [@spec.file_name, @spec.plural].include?(right[2])
+          end
+          @conflicts << "Remaining Ruby reference to #{@spec.class_name}: #{relative}" if constant || association
+        end
+      end
+
+      def preview
+        @migrations.each_key do |path|
+          status("keep", path, @migration_reasons.fetch(path))
+        end
+        unless @migrations.empty?
+          @output.puts("To remove the table, review `gemstack db:status -e #{@environment}` and roll back with " \
+                       "`gemstack db:rollback -e #{@environment}` " \
+                       "if it is the latest migration, or add a migration that drops the table. " \
+                       "These database operations can delete data; destroy never runs them.")
+        end
+        @files.each_key do |path|
+          status(@snapshots[path] ? "remove" : "missing", path)
+        end
+        @routes.each { |entry| status("unroute", "config/routes.rb", entry["line"].strip) }
+        if @files.empty? && @routes.empty?
+          @output.puts("No tracked files to remove. Resources generated before ownership tracking need manual removal.")
+        end
+        @output.puts("Dry run; no files or API contracts changed.") if @dry_run
+      end
+
+      # Recheck after interactive confirmation, before the first mutation.
+      def verify_snapshot!
+        @manifest.verify!
+
+        if @pending && !@pending.empty? && @migration_status.applied != @applied
+          raise Thor::Error, "Migration state changed or became unavailable; run destroy again"
+        end
+
+        if @auto_removed_migrations&.any? { |path, _| @migration_git_status.committed(path) != false }
+          raise Thor::Error, "Migration Git state changed; run destroy again"
+        end
+
+        @snapshots.each do |relative, original|
+          path = @manifest.absolute(relative)
+          current = File.file?(path) ? Digest::SHA256.file(path).hexdigest : nil
+          unless current == original
+            raise Thor::Error,
+                  "File changed during confirmation: #{relative}; run destroy again"
+          end
+        end
+
+        path = @manifest.absolute("config/routes.rb")
+        current = File.file?(path) ? File.read(path, encoding: "UTF-8") : ""
+        return if current == @route_content
+
+        raise Thor::Error, "Routes changed during confirmation; run destroy again"
+      end
+
+      def apply
+        @files.each_key do |relative|
+          path = @manifest.absolute(relative)
+          File.delete(path) if File.file?(path)
+        end
+        File.write(@manifest.absolute("config/routes.rb"), @route_after) unless @routes.empty?
+        @manifest.forget(@files.keys, @routes)
+        @manifest.save
+        @changed = true
+        @output.puts("Removed tracked code. Database data was not changed.")
+      end
+    end
+  end
+end

data/lib/gemstack/cli/generation_manifest.rb

@@ -0,0 +1,122 @@
+# frozen_string_literal: true
+
+require "digest"
+require "json"
+require "pathname"
+require "tempfile"
+
+module GemStack
+  class CLI < Thor
+    # Ownership, not filename guesses, determines what destroy may remove.
+    # Commit this file with the generated code so ownership survives a checkout.
+    class GenerationManifest
+      PATH = ".gemstack/generators.json"
+      VERSION = 1
+
+      attr_reader :files, :routes
+
+      def initialize(root)
+        @root = File.expand_path(root)
+        @path = absolute(PATH)
+        @fingerprint = fingerprint
+        data = File.file?(@path) ? JSON.parse(File.read(@path, encoding: "UTF-8")) : empty
+        validate!(data)
+        @files = data.fetch("files")
+        @routes = data.fetch("routes")
+        @dirty = false
+      rescue JSON::ParserError => e
+        raise Thor::Error, "Invalid #{PATH}: #{e.message}"
+      end
+
+      # Reject traversal and symlinks, including symlinked parent directories.
+      # Never follow a manifest entry outside this application, even with --force.
+      def absolute(relative)
+        parts = relative.to_s.split("/", -1)
+        if parts.empty? || parts.intersect?(["", ".", ".."]) || relative.include?("\0")
+          raise Thor::Error, "Unsafe generated path: #{relative.inspect}"
+        end
+
+        parts.reduce(@root) do |parent, part|
+          path = File.join(parent, part)
+          raise Thor::Error, "Refusing symlink: #{relative}" if File.symlink?(path)
+
+          path
+        end
+      end
+
+      def record_file(path, owner:, existed:)
+        relative = Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(@root)).to_s
+        absolute(relative)
+        previous = files[relative]
+        return if existed && (!previous || previous["owner"] != owner)
+
+        files[relative] = { "owner" => owner, "sha256" => Digest::SHA256.file(path).hexdigest }
+        @dirty = true
+      end
+
+      def record_route(line, owner:)
+        entry = { "owner" => owner, "line" => line }
+        return if routes.include?(entry)
+
+        routes << entry
+        @dirty = true
+      end
+
+      def forget(paths, removed_routes)
+        paths.each { |path| files.delete(path) }
+        @routes -= removed_routes
+        @dirty = true
+      end
+
+      def save
+        return unless @dirty
+
+        verify!
+        FileUtils.mkdir_p(File.dirname(@path))
+        data = { "version" => VERSION, "files" => files.sort.to_h, "routes" => routes }
+        Tempfile.create(["generators", ".json"], File.dirname(@path)) do |file|
+          file.write("#{JSON.pretty_generate(data)}\n")
+          file.close
+          File.rename(file.path, @path)
+        end
+        @dirty = false
+        @fingerprint = fingerprint
+      end
+
+      def verify!
+        absolute(PATH)
+        return if fingerprint == @fingerprint
+
+        raise Thor::Error, "#{PATH} changed while the command was running; retry the command"
+      end
+
+      private
+
+      def empty = { "version" => VERSION, "files" => {}, "routes" => [] }
+
+      def fingerprint = File.file?(@path) ? Digest::SHA256.file(@path).hexdigest : nil
+
+      def validate!(data)
+        valid = data.is_a?(Hash) && data["version"] == VERSION && data["files"].is_a?(Hash) &&
+                data["routes"].is_a?(Array)
+        valid &&= data["files"].all? { |path, entry| file_entry?(path, entry) }
+        valid &&= data["routes"].all? { |entry| route_entry?(entry) }
+        raise Thor::Error, "Invalid or unsupported #{PATH}; no files changed" unless valid
+      end
+
+      def file_entry?(path, entry)
+        path.is_a?(String) && entry.is_a?(Hash) && owner?(entry["owner"]) &&
+          entry["sha256"].is_a?(String) && entry["sha256"].match?(/\A[0-9a-f]{64}\z/)
+      end
+
+      def route_entry?(entry)
+        entry.is_a?(Hash) && owner?(entry["owner"]) && entry["line"].is_a?(String) &&
+          entry["line"].lines.size == 1 && entry["line"].end_with?("\n")
+      end
+
+      def owner?(owner)
+        owner.is_a?(String) && owner.match?(%r{\A(?:model|controller|resource):[a-z][a-z0-9_]*(?:/[a-z][a-z0-9_]*)*\z})
+      end
+    end
+  end
+end

data/lib/gemstack/cli/generator.rb

@@ -141,6 +141,15 @@ module GemStack
         true
       end
 
+      def write_tracked(path, content, owner:)
+        relative = Pathname.new(File.expand_path(path)).relative_path_from(Pathname.new(File.expand_path(@root))).to_s
+        @manifest.absolute(relative)
+        existed = File.exist?(path)
+        return unless write(path, content)
+
+        @manifest.record_file(path, owner: owner, existed: existed)
+      end
+
       def status(label, path, note = nil)
         shown = path.delete_prefix("#{Dir.pwd}/")
         @output.puts("  #{label.rjust(9)}  #{shown}#{"  (#{note})" if note}")

data/lib/gemstack/cli/migration_changes.rb

@@ -0,0 +1,148 @@
+# frozen_string_literal: true
+
+require "ripper"
+
+module GemStack
+  class CLI < Thor
+    # Read the generated schema as syntax, never by executing a migration.
+    # Customized or subsequently altered schemas require manual comparison.
+    class MigrationChanges
+      COLUMN_METHODS = %w[primary_key String Integer Bignum Float BigDecimal Date column foreign_key TrueClass].freeze
+
+      def initialize(generator, root:, output:)
+        @generator = generator
+        @spec = generator.spec
+        @root = root
+        @output = output
+      end
+
+      def report(paths)
+        schema = schema_from(paths)
+        return manual_review unless schema
+
+        columns, indexes = schema
+        @spec.fields.each do |field|
+          if !columns.key?(field.column)
+            @output.puts("New column #{field.column}: gemstack g migration " \
+                         "Add#{Inflector.camelize(field.name)}To#{@spec.plural_class} #{field_argument(field)}")
+          elsif columns[field.column] != declaration(@generator.migration_column(field)) ||
+                indexes.include?(field.column) != (field.index && !field.unique)
+            @output.puts("Changed column #{field.column} (#{field_argument(field)}): gemstack g migration " \
+                         "Change#{Inflector.camelize(field.name)}On#{@spec.plural_class}")
+            @output.puts("  Edit its empty change block to alter the existing column, constraints or indexes " \
+                         "on :#{@spec.table}; do not add the column again.")
+          end
+        end
+        @output.puts("Review schema changes and backfill required columns before gemstack db:migrate.")
+      end
+
+      private
+
+      def schema_from(paths)
+        return unless paths.one?
+        return if subsequent_changes?(paths.first)
+
+        create_table_body(File.read(paths.first, encoding: "UTF-8"))
+      end
+
+      def create_table_body(source)
+        statements = Ripper.sexp(source)&.fetch(1)
+        return unless statements&.one?
+
+        migration = body(statements.first)
+        return unless canonical(statements.first[1]) == canonical(Ripper.sexp("Sequel.migration")[1][0])
+        return unless migration&.one? && call(migration.first[1]) == ["change", []]
+
+        changes = body(migration.first)
+        return unless changes&.one? && call(changes.first[1]) == ["create_table", [symbol(@spec.table)]]
+
+        parse_columns(body(changes.first))
+      end
+
+      def subsequent_changes?(path)
+        Dir.glob(File.join(@root, "db/migrations/*.rb")).any? do |other|
+          other > path && File.read(other, encoding: "UTF-8").match?(/\b#{Regexp.escape(@spec.table)}\b/)
+        end
+      end
+
+      def body(node)
+        return unless node&.first == :method_add_block
+
+        block = node[2]
+        return unless block[0] == :do_block && block[1].nil?
+
+        statements = block[2]
+        statements[1] if statements[0] == :bodystmt && statements.drop(2).all?(&:nil?)
+      end
+
+      def parse_columns(statements)
+        return unless statements
+
+        columns = {}
+        indexes = []
+        statements.each do |node|
+          next if node == [:void_stmt]
+
+          name, args = call(node)
+          column = args&.first
+          return nil unless column&.dig(0) == :symbol_literal
+
+          column_name = column.dig(1, 1, 1)
+          if name == "index" && args.one?
+            indexes << column_name
+          elsif COLUMN_METHODS.include?(name) && !columns.key?(column_name)
+            columns[column_name] = [name, args]
+          else
+            return nil
+          end
+        end
+        [columns, indexes]
+      end
+
+      def declaration(source) = call(Ripper.sexp(source)[1][0])
+      def symbol(name) = canonical(Ripper.sexp(":#{name}")[1][0])
+
+      def call(node)
+        return unless node.is_a?(Array)
+
+        case node[0]
+        when :command
+          name = node[1][1]
+          arguments = node[2]
+        when :method_add_arg
+          return unless node[1][0] == :fcall
+
+          name = node[1][1][1]
+          arguments = node[2]
+          arguments = arguments[1] if arguments[0] == :arg_paren
+        else return
+        end
+        return [name, []] if arguments.nil? || arguments.empty?
+        return unless arguments[0] == :args_add_block && arguments[2] == false
+
+        [name, canonical(arguments[1])]
+      end
+
+      def canonical(node)
+        return node unless node.is_a?(Array)
+        return node.first(2) if node[0].is_a?(Symbol) && node[0].to_s.start_with?("@")
+
+        normalized = node.map { |part| canonical(part) }
+        normalized[1] = normalized[1].sort_by(&:inspect) if normalized[0] == :bare_assoc_hash
+        normalized
+      end
+
+      def field_argument(field)
+        [field.name, field.type, ("optional" if field.optional), ("unique" if field.unique),
+         ("index" if field.index && !field.reference?)].compact.join(":")
+      end
+
+      def manual_review
+        @output.puts("Cannot safely compare the retained migration with the requested fields " \
+                     "(custom schema or later migrations). Review the current :#{@spec.table} schema.")
+        @output.puts("Create a migration with gemstack g migration Update#{@spec.plural_class}Schema " \
+                     "and edit its empty change block before gemstack db:migrate.")
+      end
+    end
+  end
+end

data/lib/gemstack/cli/migration_git_status.rb

@@ -0,0 +1,34 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module GemStack
+  class CLI < Thor
+    # Unknown or incomplete history must never authorize automatic deletion.
+    class MigrationGitStatus
+      def initialize(root)
+        @root = root
+      end
+
+      def committed(path)
+        return unless git("rev-parse", "--is-inside-work-tree") == "true"
+
+        history = git("log", "--all", "-1", "--format=%H", "--", path)
+        return if history.nil?
+        return true unless history.empty?
+        return unless git("rev-parse", "--is-shallow-repository") == "false"
+
+        false
+      end
+
+      private
+
+      def git(*)
+        output, _, status = Open3.capture3("git", "--literal-pathspecs", "-C", @root, *)
+        output.strip if status.success?
+      rescue SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/gemstack/cli/migration_status.rb

@@ -0,0 +1,65 @@
+# frozen_string_literal: true
+
+require "open3"
+
+module GemStack
+  class CLI < Thor
+    # Read migration history in the app's bundle without booting its models.
+    # Unknown state is never treated as permission to delete a migration.
+    class MigrationStatus
+      PROBE = <<~RUBY
+        require "json"
+        require File.expand_path("config/app.rb")
+        abort "Database module unavailable" unless defined?(GemStack::DB)
+        settings = GemStack::DB.settings.except(:source).merge(GemStack::DB.config.options)
+        if settings[:adapter] == "sqlite"
+          abort "In-memory database has no persistent history" if settings[:database] == ":memory:"
+          unless File.exist?(settings[:database])
+            puts JSON.generate([])
+            exit
+          end
+          settings[:readonly] = true
+        end
+        Sequel.connect(**settings) do |db|
+          puts JSON.generate(GemStack::DB::Migrator.new(db).applied)
+        end
+      RUBY
+
+      def initialize(root, environment: nil)
+        @root = root
+        @environment = environment || ENV.fetch("GEMSTACK_ENV", "development")
+      end
+
+      def applied
+        return unless File.file?(File.join(@root, "config/app.rb"))
+
+        bundle_path = ENV["BUNDLE_PATH"] || Bundler.settings[:path]&.to_s if defined?(Bundler)
+
+        run = lambda do
+          Open3.capture3(
+            {
+              "BUNDLE_GEMFILE" => File.join(@root, "Gemfile"),
+              "BUNDLE_PATH" => bundle_path,
+              "BUNDLE_FROZEN" => "true",
+              "GEMSTACK_ENV" => @environment
+            }.compact,
+            "bundle",
+            "exec",
+            "ruby",
+            "-e",
+            PROBE,
+            chdir: @root
+          )
+        end
+
+        output, _, status = defined?(Bundler) ? Bundler.with_unbundled_env(&run) : run.call
+        return unless status.success?
+
+        files = JSON.parse(output.lines.last.to_s)
+        files if files.is_a?(Array) && files.all?(String)
+      rescue JSON::ParserError, SystemCallError
+        nil
+      end
+    end
+  end
+end

data/lib/gemstack/cli/resource_generator.rb

@@ -34,10 +34,13 @@ module GemStack
       end
 
       def run
+        @manifest = GenerationManifest.new(@root)
         ensure_base_classes(@root, *(%i[model serializer] & @parts))
         @parts.each { |part| render_part(part) }
         add_routes if @parts.include?(:controller)
         self
+      ensure
+        @manifest&.save
       end
 
       # --- template helpers -------------------------------------------------
@@ -127,14 +130,34 @@ module GemStack
       private
 
       def render_part(part)
+        return if part == :migration && existing_migration?
+
         template_files("resource/#{part}", override_root: @root).sort.each do |rel, source|
           next if skip?(part, rel)
 
           target = File.join(@root, substitute(rel.delete_suffix(".tt")))
-          write(target, render(File.read(source), source))
+          content = render(File.read(source, encoding: "UTF-8"), source)
+          if rel == "frontend/lib/format.ts"
+            write(target, content) # shared by every resource
+          else
+            write_tracked(target, content, owner: owner_for(part))
+          end
         end
       end
 
+      def existing_migration?
+        paths = Dir.glob(File.join(@root, "db/migrations/*_create_#{spec.table}.rb"))
+        paths.each { |path| status("keep", path, "existing create migration; use a new migration for schema changes") }
+        MigrationChanges.new(self, root: @root, output: @output).report(paths) unless paths.empty?
+        !paths.empty?
+      end
+
+      def owner_for(part)
+        return "controller:#{spec.plural}" if part == :controller
+
+        "#{part == :frontend ? "resource" : "model"}:#{spec.file_name}"
+      end
+
       def skip?(part, rel)
         return true if !tests && rel.start_with?("test/")
         return false unless part == :frontend
@@ -156,13 +179,15 @@ module GemStack
 
         only = spec.crud? ? "" : ", only: %i[#{spec.actions.join(" ")}]"
         line = "resources :#{spec.plural}#{only}"
-        content = File.read(path)
+        @manifest.absolute("config/routes.rb")
+        content = File.read(path, encoding: "UTF-8")
         return status("identical", path) if content.match?(/^\s*resources :#{spec.plural}\b/)
         unless content.match?(ControllerGenerator::ROUTES_BLOCK)
           return status("skip", path, "no `GemStack.routes do` block — add `#{line}`")
         end
 
         File.write(path, content.sub(ControllerGenerator::ROUTES_BLOCK) { |open| "#{open}  #{line}\n" })
+        @manifest.record_route("  #{line}\n", owner: "controller:#{spec.plural}")
         status("route", path, line)
       end
     end

data/lib/gemstack/cli.rb

@@ -6,11 +6,17 @@ require "gemstack/core"
 module GemStack
   # The `gemstack` command.
   class CLI < Thor
+    require_relative "cli/add_next_steps"
     require_relative "cli/project"
     require_relative "cli/generator"
+    require_relative "cli/generation_manifest"
+    require_relative "cli/migration_status"
+    require_relative "cli/migration_git_status"
+    require_relative "cli/destroy_generator"
     require_relative "cli/app_generator"
     require_relative "cli/controller_generator"
     require_relative "cli/resource_spec"
+    require_relative "cli/migration_changes"
     require_relative "cli/resource_generator"
     require_relative "cli/migration_generator"
     require_relative "cli/job_generator"
@@ -40,10 +46,7 @@ module GemStack
     GENERATORS = "resource, model, migration, controller, job, policy, deploy"
 
     map %w[-v --version] => :version
-    map "s" => :server
-    map "c" => :console
-    map "t" => :test
-    map "g" => :generate
+    map "s" => :server, "c" => :console, "t" => :test, "g" => :generate, "d" => :destroy
 
     desc "new NAME", "Create a new GemStack application (Ruby API + Next.js frontend)"
     long_desc <<~DESC
@@ -183,6 +186,12 @@ module GemStack
       end
     end
 
+    desc "destroy GENERATOR NAME", "Remove tracked generated code (alias: d): model, controller, resource"
+    DestroyGenerator.configure(self)
+    def destroy(generator = nil, name = nil)
+      DestroyGenerator.invoke(generator, name, cli: self) { |root| refresh_contract(root) }
+    end
+
     desc "add FEATURE", "Add an optional module to this app: realtime, auth, storage"
     long_desc <<~DESC
       gemstack add realtime
@@ -204,17 +213,9 @@ module GemStack
       AddGenerator.new(feature, root: root, install: !options[:skip_install]).run
       refresh_contract(root) if %w[auth
                                    storage].include?(feature) && !options[:skip_install] && !options[:skip_contract]
-      say("\n#{ADD_NEXT_STEPS.fetch(feature)}")
+      say("\n#{AddNextSteps::STEPS.fetch(feature)}")
     end
 
-    ADD_NEXT_STEPS = {
-      "realtime" => "Next: declare channels in config/channels.rb, then GemStack.broadcast(...) — see docs/realtime.md",
-      "auth" => "Next: gemstack db:migrate · open http://localhost:3000/signup · " \
-                "`before :require_login` in controllers — see docs/authentication.md",
-      "storage" => "Next: uploadFile(file) from frontend/lib/upload.ts · production: STORAGE_SERVICE=s3, S3_BUCKET " \
-                   "— see docs/storage.md"
-    }.freeze
-
     desc "doctor", "Check that this app can run (Ruby, Node, database, migrations, contract…) and how to fix it"
     long_desc <<~DESC
       gemstack doctor               checks for development
@@ -228,9 +229,7 @@ module GemStack
     end
 
     desc "version", "Print the GemStack version"
-    def version
-      say("GemStack #{GemStack::VERSION}")
-    end
+    def version = say("GemStack #{GemStack::VERSION}")
 
     no_commands do
       # -e ENV, else GEMSTACK_ENV, else development.

data/lib/gemstack/db/model.rb

@@ -36,6 +36,10 @@ module GemStack
     # clearly with "relation does not exist".
     self.require_valid_table = false
 
+    dataset_module do
+      def delete_all = delete
+    end
+
     class << self
       def gemstack_fields
         @gemstack_fields ||= superclass.respond_to?(:gemstack_fields) ? superclass.gemstack_fields.dup : {}

data/lib/gemstack/version.rb

@@ -2,5 +2,5 @@
 
 module GemStack
   # All GemStack gems are released together under a single version.
-  VERSION = "0.3.3"
+  VERSION = "0.3.4"
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: gemstack
 version: !ruby/object:Gem::Version
-  version: 0.3.3
+  version: 0.3.4
 platform: ruby
 authors:
 - Adware Technologies
@@ -44,14 +44,14 @@ dependencies:
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.3
+        version: 0.3.4
   type: :runtime
   prerelease: false
   version_requirements: !ruby/object:Gem::Requirement
     requirements:
     - - '='
       - !ruby/object:Gem::Version
-        version: 0.3.3
+        version: 0.3.4
 - !ruby/object:Gem::Dependency
   name: json
   requirement: !ruby/object:Gem::Requirement
@@ -172,17 +172,23 @@ files:
 - lib/gemstack/cache/store.rb
 - lib/gemstack/cli.rb
 - lib/gemstack/cli/add_generator.rb
+- lib/gemstack/cli/add_next_steps.rb
 - lib/gemstack/cli/app_generator.rb
 - lib/gemstack/cli/commands/db.rb
 - lib/gemstack/cli/commands/jobs.rb
 - lib/gemstack/cli/console_methods.rb
 - lib/gemstack/cli/controller_generator.rb
 - lib/gemstack/cli/deploy_generator.rb
+- lib/gemstack/cli/destroy_generator.rb
 - lib/gemstack/cli/doctor.rb
 - lib/gemstack/cli/doctor/upgrade_check.rb
+- lib/gemstack/cli/generation_manifest.rb
 - lib/gemstack/cli/generator.rb
 - lib/gemstack/cli/job_generator.rb
+- lib/gemstack/cli/migration_changes.rb
 - lib/gemstack/cli/migration_generator.rb
+- lib/gemstack/cli/migration_git_status.rb
+- lib/gemstack/cli/migration_status.rb
 - lib/gemstack/cli/policy_generator.rb
 - lib/gemstack/cli/project.rb
 - lib/gemstack/cli/resource_generator.rb