syntropy 0.38.1 → 0.40.0

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 1ec61f53807ee4049d4c5e04ae42f66f3b4824733a04cad245d150a0c72f0acc
-  data.tar.gz: ee5b563302d15d6a8d58fc7460636b5f402f726f730c42799862ceb92cafa42f
+  metadata.gz: 96429a90f9e886ffafc25c1e4c88a46157fb79751d21fdbed7af10252ff5d16e
+  data.tar.gz: 040ebeaf507ada9e986847b7630739f9451c88d5384c736fd632f55d4928bff2
 SHA512:
-  metadata.gz: 30d9fcc1b9d0db54e4faa8fa009e547d69e8b6b1beeb3684995b9c27c8f22ebffdffc5c3ec0000495aac235d21b6d61b8cb57a2e305941fc3ec00276c12d283c
-  data.tar.gz: 8453a4dfc06cba6e3cd741fb1260618af3825366cc937256cb0d2614c6dc520d5da983309c47010e493acbbae66d8a4cc50e898d3cc6723d9189364914c6579a
+  metadata.gz: f75c54e095c15c1742786f712062142619a0e7c23ee22295f3dc93825d476027ab26a962054ad3cf868f8d89045af2c3c29733b648d9042ba2594595783ab234
+  data.tar.gz: d60a7f2d439b615db027c9f678ab4fba2aae38deb1c68b9d9e5b29bdbe22d282f7d14e1111458c97e3b7ad004eef1a428714376d40bd1370fa668e08765fe739

data/CHANGELOG.md

@@ -1,3 +1,19 @@
+# 0.40.0 2026-08-24
+
+- Update UringMachine
+
+# 0.39.0 2026-06-21
+
+- Add support for embedded Papercraft snippets in Markdown files
+- Reimplement Markdown rendering
+- Increase cache-control max-age to one week
+- Add support for relative redirects, add `Request#rel`
+- Add support for concurrent loading, add mutex lock to module loader
+- Fix `Syntropy.load_config`
+- Read module source file using UringMachine
+- Raise on circular module dependency
+- Streamline CLI options across commands
+
 # 0.38.1 2026-06-13
 
 - Fix builtin app, controller extensions

data/README.md

@@ -52,6 +52,8 @@ Syntropy is based on:
 - [Extralite](https://github.com/digital-fabric/extralite) a fast and innovative
   SQLite wrapper for Ruby.
 
+Syntropy is 100% brain-coded.
+
 ## Examples
 
 To get a taste of some of Syntropy's capabilities, you can run the included

data/TODO.md

@@ -1,8 +1,54 @@
 ## Immediate
 
-- [ ] Controllers
-  - [ ] Streamline names of ready-made control methods:
-    - [ ] dispatch_json_rpc
+- [ ] Nicer logging in development mode:
+
+Nice terminal formatting with colors:
+
+```
+sharon@nf1:~/tmp/capatest2$ npx serve dist
+
+   ┌───────────────────────────────────────────┐
+   │                                           │
+   │   Serving!                                │
+   │                                           │
+   │   - Local:    http://localhost:3000       │
+   │   - Network:  http://192.168.0.106:3000   │
+   │                                           │
+   │   Copied local address to clipboard!      │
+   │                                           │
+   └───────────────────────────────────────────┘
+
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 GET /
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 Returned 200 in 42 ms
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 GET /assets/index-edfizW3i.js
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 GET /assets/index-PVjztr5e.css
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 Returned 200 in 3 ms
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 Returned 200 in 12 ms
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 GET /assets/p-Sh0ICmPV-D227nRX-.js
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 Returned 200 in 3 ms
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 GET /assets/p-C4t5ymfq-4gquBJ2r.js
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 Returned 200 in 6 ms
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 GET /assets/p-D6Ynv7Xh-CRAF8up3.js
+ HTTP  7/6/2026 8:04:23 PM 127.0.0.1 Returned 200 in 4 ms
+^C
+ INFO  Gracefully shutting down. Please wait...
+```
+
+- [ ] Ability to load modules from builtin applet
+  - [ ] Can we mount them on the app's module loader?
+
+  Why we need that? The use case is making use of a default pub/sub instance  
+
+- [ ] Pub/sub
+  - [ ] Ruby side
+  - [ ] JS side
+  - [ ] Reimplement `auto_refresh` using a *default* event bus provided by
+        Syntropy
+
+- [ ] An alternative to the pub/sub design - add streaming responses to the
+  JSON/jS API (using SSE).
+
+## Collections
 
 - [ ] Collection - treat directories and files as collections of data.
 
@@ -34,7 +80,6 @@
 
 - [ ] Improve serving of static files:
   - [ ] support for compression
-  - [ ] support for caching headers
   - [ ] add `Request#render_static_file(route, fn)
 
 ## Missing for a first public release
@@ -43,21 +88,18 @@
 - [ ] Website
 - [v] Frontend part of JSON API
 - [v] Auto-refresh page when file changes
-- [ ] SQLite database capabilities
-  - [ ] Stores
-    - [ ] KV store (with TTL)
 - [v] Examples
   - [v] Reactive app - counter or some other simple app showing interaction with
     server
-  - [ ] blog
+  - [v] blog
 
 ## Testing facilities
 
 - What do we need to test?
-  - Routes
-  - Route responses
-  - Changes to state / DB
-  - Rendered HTML - presence of certain markup / elements / text
+  - [v] Routes
+  - [v] Route responses
+  - [v] Changes to state / DB
+  - [ ] Rendered HTML - presence of certain markup / elements / text
 
 ## Support for applets
 
@@ -93,138 +135,7 @@ class Syntropy::Admin < Syntropy::App
 end
 ```
 
-## Response: cookies and headers
-
-We need a way to inject cookies into the response. This probably should be done
-in the TP2 code:
-
-```ruby
-@@default_set_cookie_attr = 'HttpOnly'
-def self.default_set_cookie_attr=(v)
-  @@default_set_cookie_attr = v
-end
-
-def set_cookie(key, value, attr = @@default_set_cookie_attr)
-  @buffered_headers ||= +''
-  @buffered_headers << format(
-    "Set-Cookie: %<key>s=%<value>s; %<attr>s\n",
-    key:, value:, attr:
-  )
-end
-
-def set_headers(headers)
-  @buffered_headers ||= +''
-  @buffered_headers << format_headers(headers)
-end
-
-...
-
-req.set_cookie('at', 'foobar', 'SameSite=none; Secure; HttpOnly')
-```
-
-## Middleware
-
-Some standard middleware:
-
-- request rewriter
-- logger
-- auth
-- selector + terminator
-
-```Ruby
-# For the chainable DSL shown below, we need to create a custom class:
-class Syntropy::Middleware::Selector
-  def initialize(select_proc, terminator_proc = nil)
-    @select_proc = select_proc
-    @terminator_proc = terminator_proc
-  end
-
-  def to_proc
-    ->(req, proc) {
-      @select_proc.(req) ? @terminator_proc.(req) : proc(req)
-    }
-  end
-
-  def terminate(&proc)
-    @terminator_proc = proc
-  end
-end
-```
-
-```Ruby
-# a _site.rb file can be used to wrap a whole app
-# site/_site.rb
-
-# this means we route according to the host header, with each
-export Syntropy.route_by_host
-
-# we can also rewrite requests:
-rewriter = Syntropy
-  .select { it.host =~ /^tolkora\.(org|com)$/ }
-  .terminate { it.redirect_permanent('https://tolkora.net') }
-
-# This is actuall a pretty interesting DSL design:
-# a chain of operations that compose functions. So, we can select a
-export rewriter.wrap(default_app)
-
-# composing
-export rewriter.wrap(Syntropy.some_custom_app.wrap(app))
-
-# or maybe
-export rewriter << some_other_middleware << app
-```
-
-## CLI tool for setting up a site repo:
-
-```bash
-# clone a newly created repo
-~/repo$ git clone https://github.com/foo/bar
-...
-~/repo$ syntropy setup bar
-
-(syntropy banner)
-
-Setting up Syntropy project in /home/sharon/repo/bar:
-
-bar/
-  bin/
-    start
-    stop
-    restart
-    console
-    server
-  docker-compose.yml
-  Dockerfile
-  Gemfile
-  proxy/
-  README.md
-  site/
-    _layout/
-      default.rb
-    _lib/
-    about.md
-    articles/
-      long-form.md
-    assets/
-      js/
-      css/
-        style.css
-      img/
-        syntropy.png
-    index.rb
-```
-
-Some of the files might need templating, but we can maybe do without, or at
-least make it as generic as possible.
-
-`syntropy setup` steps:
-
-1. Verify existence of target directory
-2. Copy files from Syntropy template to target directory
-3. Do chmod +x for bin/*
-4. Do bundle install in the target directory
-5. Show some information with regard to how to get started working with the
-   repo
+## Some more CLI commands
 
 `syntropy provision` steps:
 

data/cmd/console.rb

@@ -17,11 +17,11 @@ env = {
 parser = OptionParser.new do |o|
   o.banner = 'Usage: syntropy console [options]'
 
-  o.on('-a', '--app PATH', 'Set app directory (default: ./app') do |path|
+  o.on('-a', '--app PATH', 'Set app directory (default: ./app)') do |path|
     env[:app_root] = path
   end
 
-  o.on('-c', '--config PATH', 'Set config directory (default: ./config') do |path|
+  o.on('-c', '--config PATH', 'Set config directory (default: ./config)') do |path|
     env[:config_root] = path
   end
 
@@ -72,8 +72,6 @@ env[:logger] = env[:logger] && Syntropy::Logger.new(env[:machine], **env)
 @app = Syntropy::App.load(env)
 @env = env
 @machine = env[:machine]
-@connection_pool = @app.connection_pool if @app.respond_to?(:connection_pool)
-@schema = @app.schema if @app.respond_to?(:schema)
 @module_loader = @app.module_loader
 
 require 'uringmachine/fiber_scheduler'

data/cmd/new/template/config/production.rb

@@ -1,4 +1,5 @@
 export(
-  storage:
+  storage: {
     path: ENV['DATABASE_PATH'] || 'storage/production.db'
+  }
 )

data/cmd/new.rb

@@ -44,7 +44,7 @@ template_path = File.join(__dir__, 'new/template')
 begin
   `mkdir -p "#{path}"`
   system("cp -rv#{opts[:yes] ? '' : 'i'} #{template_path}/* \"#{path}/\"")
-  puts "Your app is ready in #{path}"
+  puts "Your app is ready in #{full_path}"
 rescue => e
   p e
   p e.backtrace

data/cmd/serve.rb

@@ -20,17 +20,16 @@ env = {
 parser = OptionParser.new do |o|
   o.banner = 'Usage: syntropy serve [options]'
 
-  o.on('-a', '--app PATH', 'Set app directory (default: ./app') do |path|
+  o.on('-a', '--app PATH', 'Set app directory (default: ./app)') do |path|
     env[:app_root] = path
   end
 
-  o.on('-b', '--bind BIND', String,
-       'Bind address (default: http://0.0.0.0:1234). You can specify this flag multiple times to bind to multiple addresses.') do
+  o.on('-b', '--bind ADDRESS', String, 'Bind address (default: 0.0.0.0:1234)') do
     env[:bind] ||= []
     env[:bind] << it
   end
 
-  o.on('-c', '--config PATH', 'Set config directory (default: ./config') do |path|
+  o.on('-c', '--config PATH', 'Set config directory (default: ./config)') do |path|
     env[:config_root] = path
   end
 
@@ -100,4 +99,30 @@ Fiber.set_scheduler(UM::FiberScheduler.new(env[:machine]))
 require 'syntropy/dev_mode' if Syntropy.dev_mode
 
 app = Syntropy::App.load(env)
+
+if env[:mode] == 'development'
+  @main_fiber = Fiber.current
+  env[:machine].spin do
+    @app = app
+    @env = env
+    @machine = env[:machine]
+    @module_loader = @app.module_loader
+
+    loop do
+      puts "Enter command: (c + Enter to open console, q + Enter to quit)"
+      command = $stdin.gets.chomp
+      case command
+      when 'c'
+        t = Thread.new {
+          require 'irb'
+          IRB.start
+        }
+        t.join
+      when 'q'
+        @machine.schedule(@main_fiber, UM::Terminate.new)
+      end
+    end
+  end
+end
+
 Syntropy.run(env) { app.call(it) }

data/cmd/test.rb

@@ -16,11 +16,11 @@ MINITEST_ARGV = []
 parser = OptionParser.new do |o|
   o.banner = 'Usage: syntropy test [options]'
 
-  o.on('-a', '--app PATH', 'Set app directory (default: ./app') do |path|
+  o.on('-a', '--app PATH', 'Set app directory (default: ./app)') do |path|
     env[:app_root] = path
   end
 
-  o.on('-c', '--config PATH', 'Set config directory (default: ./config') do |path|
+  o.on('-c', '--config PATH', 'Set config directory (default: ./config)') do |path|
     env[:config_root] = path
   end
 
@@ -29,6 +29,10 @@ parser = OptionParser.new do |o|
     exit
   end
 
+  o.on('-f', '--file PATH', 'Set test file') do |path|
+    env[:test_file] = path
+  end
+
   o.on('-m', '--mount PATH', 'Set mount path (default: /)') do |path|
     env[:mount_path] = path
     env[:builtin_applet_path] = File.join(path, '.syntropy')
@@ -82,7 +86,11 @@ Syntropy.load_config(env)
 $stdout.sync = true
 $stderr.sync = true
 
-Dir.glob("#{File.expand_path(env[:test_root])}/test_*.rb").each { require(it) }
+if env[:test_file]
+  require(File.expand_path(env[:test_file]))
+else
+  Dir.glob("#{File.expand_path(env[:test_root])}/test_*.rb").each { require(it) }
+end
 
 def restart_on_file_change(machine, dir, restart_argv)
   machine.file_watch(dir, UM::IN_CREATE | UM::IN_DELETE | UM::IN_CLOSE_WRITE) {
@@ -92,7 +100,7 @@ def restart_on_file_change(machine, dir, restart_argv)
   exec('ruby', __FILE__, *restart_argv)
 end
 
-Syntropy::Test.env = (env)
+Syntropy::Test.global_env = env
 Minitest.run MINITEST_ARGV
 
 if env[:watch_mode]

data/examples/agent/Dockerfile

@@ -0,0 +1,25 @@
+FROM ruby:4.0-slim AS base
+WORKDIR /syntropy
+RUN apt-get update -qq && apt-get install -y \
+    curl \
+    build-essential \
+    libpq-dev \
+    libsqlite3-dev \
+    libssl-dev \
+    libyaml-dev \
+    pkg-config && \
+    rm -rf /var/lib/apt/lists /var/cache/apt/archives
+
+ENV BUNDLE_PATH="/usr/local/bundle"
+COPY Gemfile Gemfile.lock ./
+RUN bundle install
+
+RUN groupadd --system --gid 1000 syntropy && \
+    useradd syntropy --uid 1000 --gid 1000 --create-home --shell /bin/bash
+USER 1000:1000
+
+EXPOSE 1234
+
+# Start the main process
+# CMD ["bash"]
+CMD ["bundle", "exec", "syntropy", "serve"]

data/examples/agent/Gemfile

@@ -0,0 +1,3 @@
+source 'https://gem.coop'
+
+gem 'syntropy', '~>0.39.0', path: '../..'

data/examples/agent/README.md

@@ -0,0 +1,40 @@
+# My awesome Syntropy app
+
+## Installation
+
+```bash
+$ bundle install
+```
+
+## Running the web server
+
+```bash
+$ bundle exec syntropy serve
+```
+
+## Starting the app console
+
+```bash
+$ bundle exec syntropy console
+```
+
+### Running tests
+
+```bash
+$ bundle exec syntropy tests
+```
+
+### Usage with Docker Compose
+
+You can also run the app on Docker Compose:
+
+```bash
+# run the app server
+$ docker compose up
+
+# run the console
+$ docker compose run --remove-orphans console
+
+# run tests
+$ docker compose run --remove-orphans test
+```

data/examples/agent/TODO.md

@@ -0,0 +1,5 @@
+- switch to JS modules, reorganize code
+- bring it over to the Reality code
+- Implement error response from tool (using try..catch)
+- Implement OpenRouter OAuth integration (can it work  on localhost?)
+-

data/examples/agent/app/_layout/default.rb

@@ -0,0 +1,15 @@
+export template { |**props|
+  html {
+    head {
+      title "My awesome Syntropy web app"
+      meta charset: 'utf-8'
+      meta name: 'viewport', content: 'width=device-width, initial-scale=1.0'
+      link rel: "stylesheet", href: 'https://cdn.simplecss.org/simple.min.css'
+      # link rel: "stylesheet", type: "text/css", href: "/assets/style.css"
+    }
+    body {
+      render_children(**props)
+      auto_refresh!
+    }
+  }
+}

data/examples/agent/app/_lib/storage.rb

@@ -0,0 +1,13 @@
+export self
+
+def connection_pool
+  @connection_pool ||= Storage::ConnectionPool.new(@machine, @env[:config][:storage][:path], 4)
+end
+
+def schema
+  Storage::Schema.new(module_loader: @module_loader, schema_root: '_schema')
+end
+
+def migrate!
+  schema.apply(connection_pool)
+end

data/examples/agent/app/_schema/2026-01-01-initial.rb

@@ -0,0 +1,9 @@
+export ->(db) {
+  # db.execute <<~SQL
+  #   create table posts (
+  #     id integer primary key autoincrement,
+  #     title text,
+  #     body text
+  #   )
+  # SQL
+}

data/examples/agent/app/assets/agent.js

@@ -0,0 +1,63 @@
+import * as UI    from './ui.js';
+import * as Model from './model.js';
+import * as Tools from './tools.js';
+
+export async function runPromptExchange(callHandler) {
+  const section = UI.createNewSection();
+  const prompt = await UI.askPrompt(section);
+  UI.addSectionEntryMarkdown(section, `*Prompt*: ${prompt}`);
+  const ctx = Model.buildExchangeBody(prompt);
+
+  while (true) {
+    UI.addPendingEntry(section);
+    const response = await Model.query(ctx);
+    UI.removePendingEntry(section);
+    if (!(await processResponse(section, ctx, response, callHandler)))
+      break;
+  }
+}
+
+async function processResponse(section, ctx, response, callHandler) {
+  const first_choice = response.choices[0];
+  if (first_choice.finish_reason == "tool_calls") {
+    Model.addMessage(ctx, first_choice.message);
+    const tool_calls = first_choice.message.tool_calls;
+    const tool_results = await performToolCalls(section, ctx, tool_calls, callHandler);
+    console.log("tool results", tool_results);
+    Model.mergeToolResults(ctx, tool_results);
+    return true;
+  }
+  else if (first_choice.finish_reason == "stop") {
+    UI.addSectionEntryMarkdown(section, first_choice.message.content);
+    return false;
+  }
+  
+}
+
+async function performToolCalls(section, ctx, tool_calls, callHandler) {
+  const pending = tool_calls.map(async (c) => await runTool(section, ctx, callHandler, c));
+  return await Promise.all(pending);
+}
+
+async function runTool(section, ctx, callHandler, call) {
+  UI.addSectionEntryMarkdown(section, `Running \`${call.function.name}(${call.function.arguments})\``);
+  const name = call.function.name;
+  const args = JSON.parse(call.function.arguments);
+  try {
+    const res = await callHandler(name, args);
+    return {
+      id: call.id,
+      result: res
+    }
+  }
+  catch (e) {
+    return {
+      id: call.id,
+      error: e.message
+    }
+  }
+}
+
+
+
+runPromptExchange(Tools.toolHandler);