raindown 0.16.1 → 0.17.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 3f181e2b7e348aefd77d7f22eef4aee64e16022ba3050d04493b829fbdabff7b
-  data.tar.gz: 9388ac597b48b784229155e26a96c535b67eb6ff84a277450d1c43d4e117b004
+  metadata.gz: c619df9532ee1f014b8837488ac3fe8cc4b3183e7abad17791fb27bb74491499
+  data.tar.gz: aad7d7aefc311af905d14afecd4960096b9cebab871c2da957e4ca05cb85c503
 SHA512:
-  metadata.gz: 6f0c4bd5677aa6f16058b8528f6af05f4ced2d4f8e4107225ae549e4d1c01e001342e45b8acf3f4e853034692094bcc684c5c8fc89d614ce39651e8307dbafc7
-  data.tar.gz: e2d10247dc4718f13909849c12feeed14a8c78e73e3de470908a3ed5684b36e0d4663c7cdbfaf45ba10a41a204f169922482739c3c81b49537df17d77a383ed4
+  metadata.gz: 91c9a12c3bd15d3c9f4ba9e41f645ee5f6ca8447b6208c38d3dd422702acc5f2395161ddb47ae60f248af9707d3c9d53edfa0d4d1dccb78d8aee99987e5c8de3
+  data.tar.gz: cd30f02347aae3834e30c0d77e8ee62b74379f005b844ef8c6b6f03f0638ad11ee7da3980b0978c4145b67dbd3144ce395c4abc7c6d8e2f57102a8e2afeb5534

data/lib/raindown/cli.rb

@@ -10,6 +10,7 @@ require_relative 'blueprints'
 require_relative 'editing'
 require_relative 'rewriter'
 require_relative 'server'
+require_relative 'skeleton'
 require_relative 'watcher/file_watcher'
 require_relative 'watcher/supervisor'
 
@@ -32,6 +33,8 @@ module Raindown
                             PATH is a file, or a directory (default: current directory) whose projects with a
                             .raindown folder are watched
         init [DIRECTORY]    Create a .raindown folder for the project's config and nodes (default: current directory)
+        skeleton            Set this repo up to commit directives without what they write, in files with "skeleton: true"
+        skeleton --check    Exit with 1, naming any such file with output staged, for CI
         server              Keep Raindown loaded for an editor, answering a JSON request a line on stdin with its HTML,
                             or its Markdown as it would be written back, like --stdin and --stdin --rewrite
         blueprints            Save the blueprints in Claude Code's last reply to .raindown/data/blueprints.md, for the terminal
@@ -78,17 +81,22 @@ module Raindown
     def self.run(argv)
       # Markdown is UTF-8 whatever the locale, as an app opened from the Dock, like Obsidian, starts Raindown without one.
       Encoding.default_external = Encoding::UTF_8
-      return if command(argv)
-
-      # Without a path, like "raindown", "raindown -x" or "raindown watch", it's the current directory.
-      argv = ['watch', '.', *argv.drop(1)] if argv.first == 'watch' && (argv.size == 1 || argv[1].start_with?('-'))
-      argv = ['.', *argv] if argv.empty? || argv.first.start_with?('-')
+      return if command(argv) || Skeleton.run_command(argv)
 
+      argv = with_path(argv)
       super || abort("Unknown arguments: #{argv.join(' ')}\n\n#{USAGE}")
     rescue StandardError => e
       report(e, path: argv.first)
     end
 
+    # Without a path, like "raindown", "raindown -x" or "raindown watch", it's the current directory.
+    def self.with_path(argv)
+      return ['watch', '.', *argv.drop(1)] if argv.first == 'watch' && (argv.size == 1 || argv[1].start_with?('-'))
+      return ['.', *argv] if argv.empty? || argv.first.start_with?('-')
+
+      argv
+    end
+
     # The :path line would match help, version and init as the file, so they're checked first.
     # Returns true when argv was one of them.
     def self.command(argv)

data/lib/raindown/server.rb

@@ -13,7 +13,7 @@ module Raindown
   #   {"id": 1, "path": "/notes/a.md", "markdown": "<!-- toc: -->", "rewrite": true}
   #   {"id": 1, "output": "<!-- toc: -->\n- ...", "warnings": []}
   # Rewriting answers like --stdin --rewrite, with "execute" like -x, and otherwise it's HTML, like --stdin. An error's
-  # answered as {"id": 1, "error": "raindown: /notes/a.md: ..."}, like the CLI writes it.
+  # answered as {"id": 1, "error": "/notes/a.md: ..."}, like the CLI writes it.
   # Each project renders in a worker of its own, which starts again when its .raindown folder changes, so its nodes,
   # config and schemas are never stale. Without fork, as on Windows, node changes need the server started again.
   class Server
@@ -33,13 +33,14 @@ module Raindown
 
     private
 
+    # Any error is the answer, as an editor's only got its server, and one note can't be allowed to stop it.
     def answer(line)
       request = JSON.parse(line)
       { id: request['id'], **edit(request) }
-    rescue JSON::ParserError, KeyError => e
-      { id: request&.dig('id'), error: "raindown: #{e.message}" }
     rescue Workers::Worker::Error => e
-      { id: request['id'], error: "raindown: #{request['path']}: #{e.message}" }
+      { id: request['id'], error: "#{request['path']}: #{e.message}" }
+    rescue StandardError => e
+      { id: (request['id'] if request.is_a?(Hash)), error: e.message.to_s }
     end
 
     def edit(request)
@@ -59,7 +60,7 @@ module Raindown
     end
 
     def nodes_changed?(project)
-      stamp = Dir.glob(File.join(project, Nodes::FOLDER, '**', '*')).to_h { [it, File.mtime(it)] }
+      stamp = Dir.glob(File.join(project, Nodes::FOLDER, '**', '*')).to_h { [it, File.lstat(it).mtime] }
       changed = @stamps.key?(project) && @stamps[project] != stamp
       @stamps[project] = stamp
       changed

data/lib/raindown/skeleton.rb

@@ -0,0 +1,114 @@
+# frozen_string_literal: true
+
+require 'open3'
+
+require_relative 'bare_directives'
+require_relative 'document'
+require_relative 'front_matter'
+require_relative 'nodes'
+require_relative 'pages'
+require_relative 'utils'
+
+module Raindown
+  # A file with "skeleton: true" in its front matter keeps its directives in git, but not what they write, so dashboards
+  # don't fill its history and sensitive reports stay out of it. It's a git clean filter: the file on disk keeps its
+  # output, and what's committed doesn't, which a clone writes again when it's rendered. The filter's required, so when
+  # a file can't be stripped, git stops rather than commit its output.
+  module Skeleton
+    FILTER = 'raindown'
+    SKELETON = /^skeleton:[ \t]*true[ \t]*$/
+
+    module_function
+
+    # Returns true when the arguments were "raindown skeleton", with --check or a file or neither.
+    def run_command(argv)
+      return false unless argv.first == 'skeleton' && argv.size <= 2
+
+      run(argv[1])
+      true
+    end
+
+    # "raindown skeleton" sets the repo up, --check is for CI, and with a file it's git's filter.
+    def run(argument)
+      root, = Open3.capture2('git', 'rev-parse', '--show-toplevel')
+      abort('raindown skeleton needs a git repo') if root.strip.empty?
+      return install(root.strip) unless argument
+      return check(root.strip) if argument == '--check'
+
+      filter(argument)
+    end
+
+    # From stdin to stdout, which it has to itself, so what nodes print goes to stderr, like the server's answers.
+    def filter(path)
+      output = $stdout.dup
+      $stdout.reopen($stderr)
+      output.write(strip($stdin.read, path:))
+    end
+
+    def check(root)
+      files = staged_output(root)
+      return if files.empty?
+
+      warn('Output is staged in these skeleton files. Run "raindown skeleton", then "git add --renormalize .":', *files)
+      exit 1
+    end
+
+    # The Markdown without what its directives wrote, or as it is, to the byte, without "skeleton: true".
+    def strip(markdown, path:)
+      return markdown unless skeleton?(markdown)
+
+      FrontMatter.parse(markdown) # Raises when it can't be read, as bare directives would be missed.
+      Nodes.load(path)
+      markdown = markdown.gsub("\r\n", "\n")
+      lines = markdown.lines
+      outputs(markdown, path).reverse_each { |output| lines.slice!((output.begin - 1)..(output.end - 1)) }
+      lines.join
+    end
+
+    # Sets the filter up for a repo. Git keeps a filter's command in its own config, so each clone needs this.
+    def install(root)
+      { clean: "#{FILTER} skeleton %f", smudge: 'cat', required: 'true' }.each do |name, value|
+        system('git', 'config', "filter.#{FILTER}.#{name}", value, chdir: root, exception: true)
+      end
+      add_attributes(File.join(root, '.gitattributes'))
+    end
+
+    # The staged files that still have output, like ones added before the filter was set up, or in a clone without it.
+    def staged_output(root)
+      tracked(root).reject do |path|
+        staged = staged_markdown(root, path)
+        strip(staged, path: File.join(root, path)) == staged
+      end
+    end
+
+    # Read from the front matter's text, so a file with front matter that isn't valid YAML, or isn't UTF-8, can still be
+    # committed when it isn't a skeleton.
+    def skeleton?(markdown)
+      markdown.scrub.match(FrontMatter::PATTERN)&.[](1)&.match?(SKELETON) || false
+    end
+
+    def outputs(markdown, path)
+      bare = BareDirectives.enabled?(path:, content: markdown)
+      Document.new(markdown:, bare:).directives.select(&:writes).filter_map(&:output)
+    end
+
+    def add_attributes(path)
+      existing = File.exist?(path) ? File.read(path) : ''
+      missing = Pages::EXTENSIONS.map { "*.#{it} filter=#{FILTER}" }.reject { existing.include?(it) }
+      return if missing.empty?
+
+      existing += "\n" unless existing.empty? || existing.end_with?("\n")
+      File.write(path, "#{existing}#{missing.join("\n")}\n")
+    end
+
+    def tracked(root)
+      output, = Open3.capture2('git', 'ls-files', '-z', chdir: root)
+      output.split("\0").select { Pages::EXTENSIONS.include?(File.extname(it).delete_prefix('.').downcase) }
+    end
+
+    def staged_markdown(root, path)
+      output, = Open3.capture2('git', 'show', ":#{path}", chdir: root)
+      output.force_encoding(Encoding::UTF_8)
+    end
+  end
+end

data/lib/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Raindown
-  VERSION = '0.16.1'
+  VERSION = '0.17.1'
 end

metadata

@@ -1,13 +1,13 @@
 --- !ruby/object:Gem::Specification
 name: raindown
 version: !ruby/object:Gem::Version
-  version: 0.16.1
+  version: 0.17.1
 platform: ruby
 authors:
 - maedi
 bindir: bin
 cert_chain: []
-date: 2026-11-07 00:00:00.000000000 Z
+date: 2026-11-08 00:00:00.000000000 Z
 dependencies:
 - !ruby/object:Gem::Dependency
   name: antlers
@@ -251,6 +251,7 @@ files:
 - lib/raindown/projects.rb
 - lib/raindown/rewriter.rb
 - lib/raindown/server.rb
+- lib/raindown/skeleton.rb
 - lib/raindown/stat.rb
 - lib/raindown/table/markdown_table.rb
 - lib/raindown/table/table.rb