nightingale 0.1.0

data/frontend/src/index.css

@@ -0,0 +1,76 @@
+@tailwind base;
+@tailwind components;
+@tailwind utilities;
+ 
+@layer base {
+  :root {
+    --background: 0 0% 100%;
+    --foreground: 222.2 84% 4.9%;
+ 
+    --card: 0 0% 100%;
+    --card-foreground: 222.2 84% 4.9%;
+ 
+    --popover: 0 0% 100%;
+    --popover-foreground: 222.2 84% 4.9%;
+ 
+    --primary: 222.2 47.4% 11.2%;
+    --primary-foreground: 210 40% 98%;
+ 
+    --secondary: 210 40% 96.1%;
+    --secondary-foreground: 222.2 47.4% 11.2%;
+ 
+    --muted: 210 40% 96.1%;
+    --muted-foreground: 215.4 16.3% 46.9%;
+ 
+    --accent: 210 40% 96.1%;
+    --accent-foreground: 222.2 47.4% 11.2%;
+ 
+    --destructive: 0 84.2% 60.2%;
+    --destructive-foreground: 210 40% 98%;
+ 
+    --border: 214.3 31.8% 91.4%;
+    --input: 214.3 31.8% 91.4%;
+    --ring: 222.2 84% 4.9%;
+ 
+    --radius: 0.5rem;
+  }
+ 
+  .dark {
+    --background: 222.2 84% 4.9%;
+    --foreground: 210 40% 98%;
+ 
+    --card: 222.2 84% 4.9%;
+    --card-foreground: 210 40% 98%;
+ 
+    --popover: 222.2 84% 4.9%;
+    --popover-foreground: 210 40% 98%;
+ 
+    --primary: 210 40% 98%;
+    --primary-foreground: 222.2 47.4% 11.2%;
+ 
+    --secondary: 217.2 32.6% 17.5%;
+    --secondary-foreground: 210 40% 98%;
+ 
+    --muted: 217.2 32.6% 17.5%;
+    --muted-foreground: 215 20.2% 65.1%;
+ 
+    --accent: 217.2 32.6% 17.5%;
+    --accent-foreground: 210 40% 98%;
+ 
+    --destructive: 0 62.8% 30.6%;
+    --destructive-foreground: 210 40% 98%;
+ 
+    --border: 217.2 32.6% 17.5%;
+    --input: 217.2 32.6% 17.5%;
+    --ring: 212.7 26.8% 83.9%;
+  }
+}
+ 
+@layer base {
+  * {
+    @apply border-border;
+  }
+  body {
+    @apply bg-background text-foreground;
+  }
+}

data/frontend/src/lib/utils.ts

@@ -0,0 +1,6 @@
+import { type ClassValue, clsx } from "clsx"
+import { twMerge } from "tailwind-merge"
+
+export function cn(...inputs: ClassValue[]) {
+  return twMerge(clsx(inputs))
+}

data/frontend/src/main.tsx

@@ -0,0 +1,10 @@
+import React from 'react'
+import ReactDOM from 'react-dom/client'
+import App from './App'
+import './index.css'
+
+ReactDOM.createRoot(document.getElementById('root')!).render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>,
+)

data/frontend/tailwind.config.ts

@@ -0,0 +1,77 @@
+/** @type {import('tailwindcss').Config} */
+module.exports = {
+  darkMode: ["class"],
+  content: [
+    './pages/**/*.{ts,tsx}',
+    './components/**/*.{ts,tsx}',
+    './app/**/*.{ts,tsx}',
+    './src/**/*.{ts,tsx}',
+  ],
+  prefix: "",
+  theme: {
+    container: {
+      center: true,
+      padding: "2rem",
+      screens: {
+        "2xl": "1400px",
+      },
+    },
+    extend: {
+      colors: {
+        border: "hsl(var(--border))",
+        input: "hsl(var(--input))",
+        ring: "hsl(var(--ring))",
+        background: "hsl(var(--background))",
+        foreground: "hsl(var(--foreground))",
+        primary: {
+          DEFAULT: "hsl(var(--primary))",
+          foreground: "hsl(var(--primary-foreground))",
+        },
+        secondary: {
+          DEFAULT: "hsl(var(--secondary))",
+          foreground: "hsl(var(--secondary-foreground))",
+        },
+        destructive: {
+          DEFAULT: "hsl(var(--destructive))",
+          foreground: "hsl(var(--destructive-foreground))",
+        },
+        muted: {
+          DEFAULT: "hsl(var(--muted))",
+          foreground: "hsl(var(--muted-foreground))",
+        },
+        accent: {
+          DEFAULT: "hsl(var(--accent))",
+          foreground: "hsl(var(--accent-foreground))",
+        },
+        popover: {
+          DEFAULT: "hsl(var(--popover))",
+          foreground: "hsl(var(--popover-foreground))",
+        },
+        card: {
+          DEFAULT: "hsl(var(--card))",
+          foreground: "hsl(var(--card-foreground))",
+        },
+      },
+      borderRadius: {
+        lg: "var(--radius)",
+        md: "calc(var(--radius) - 2px)",
+        sm: "calc(var(--radius) - 4px)",
+      },
+      keyframes: {
+        "accordion-down": {
+          from: { height: "0" },
+          to: { height: "var(--radix-accordion-content-height)" },
+        },
+        "accordion-up": {
+          from: { height: "var(--radix-accordion-content-height)" },
+          to: { height: "0" },
+        },
+      },
+      animation: {
+        "accordion-down": "accordion-down 0.2s ease-out",
+        "accordion-up": "accordion-up 0.2s ease-out",
+      },
+    },
+  },
+  plugins: [require("tailwindcss-animate"), require("@tailwindcss/typography")],
+}

data/frontend/tsconfig.json

@@ -0,0 +1,30 @@
+{
+  "compilerOptions": {
+    "target": "ES2020",
+    "useDefineForClassFields": true,
+    "lib": ["ES2020", "DOM", "DOM.Iterable"],
+    "module": "ESNext",
+    "skipLibCheck": true,
+
+    /* Bundler mode */
+    "moduleResolution": "bundler",
+    "allowImportingTsExtensions": true,
+    "resolveJsonModule": true,
+    "isolatedModules": true,
+    "noEmit": true,
+    "jsx": "react-jsx",
+
+    /* Linting */
+    "strict": true,
+    "noUnusedLocals": true,
+    "noUnusedParameters": true,
+    "noFallthroughCasesInSwitch": true,
+    
+    "baseUrl": ".",
+    "paths": {
+      "@/*": ["./src/*"]
+    }
+  },
+  "include": ["src"],
+  "references": [{ "path": "./tsconfig.node.json" }]
+}

data/frontend/tsconfig.node.json

@@ -0,0 +1,10 @@
+{
+  "compilerOptions": {
+    "composite": true,
+    "skipLibCheck": true,
+    "module": "ESNext",
+    "moduleResolution": "bundler",
+    "allowSyntheticDefaultImports": true
+  },
+  "include": ["vite.config.ts"]
+}

data/frontend/vite.config.ts

@@ -0,0 +1,13 @@
+import { defineConfig } from 'vite'
+import react from '@vitejs/plugin-react'
+import path from 'path'
+
+// https://vitejs.dev/config/
+export default defineConfig({
+  plugins: [react()],
+  resolve: {
+    alias: {
+      "@": path.resolve(__dirname, "./src"),
+    },
+  },
+})

data/lib/nightingale/cli.rb

@@ -0,0 +1,126 @@
+# frozen_string_literal: true
+
+require "fileutils"
+require "socket"
+
+module Nightingale
+  class CLI
+    def self.new_project(name)
+      puts "Creating new Nightingale project: #{name}..."
+      FileUtils.mkdir_p(name)
+
+      # Copy frontend template
+      # In a real gem, this would be properly located.
+      # For this repo, we assume we are running from the root.
+      gem_root = File.expand_path("../..", __dir__)
+      frontend_template = File.join(gem_root, "frontend")
+
+      if File.directory?(frontend_template)
+        puts "Copying frontend template..."
+        FileUtils.cp_r(frontend_template, File.join(name, "frontend"))
+
+        # Clean up node_modules and other artifacts from the template copy
+        FileUtils.rm_rf(File.join(name, "frontend", "node_modules"))
+        FileUtils.rm_rf(File.join(name, "frontend", "dist"))
+        FileUtils.rm_rf(File.join(name, "frontend", ".git"))
+
+        # Create a basic app.rb
+        puts "Creating sample app.rb..."
+        File.write(File.join(name, "app.rb"), <<~RUBY)
+          require 'nightingale'
+
+          title "My Nightingale App"
+          markdown "Welcome to your new app!"
+
+          if button "Click me"
+            markdown "You clicked the button!"
+          end
+        RUBY
+
+        # Create Gemfile
+        puts "Creating Gemfile..."
+        File.write(File.join(name, "Gemfile"), <<~RUBY)
+          source 'https://rubygems.org'
+          gem 'nightingale', path: '#{gem_root}' # Local path for now
+        RUBY
+
+        puts "Installing frontend dependencies..."
+        Dir.chdir(File.join(name, "frontend")) do
+          system("npm install")
+
+          puts "Initializing Shadcn UI components..."
+          # We assume components.json and tailwind.config.js are already in the template
+          # So we just need to add the components
+          # Note: 'shadcn add --all' might require interaction or confirmation, adding --yes or similar if available
+          # Actually, shadcn add doesn't have a --yes flag usually, but we can try piping yes?
+          # Or just installing specific components we use.
+          # For now, let's install the ones we use in the template if any, or just let the user do it?
+          # The user request said: "when user initialize the app will install them automatically"
+          # Let's try to install button, slider, etc.
+
+          # But wait, we haven't actually implemented the Shadcn components in our App.tsx yet.
+          # We are still using HTML buttons.
+          # We should update App.tsx to use Shadcn components first?
+          # Or we install them now and the user can use them.
+
+          # Let's install common components
+          components = %w[button slider card input label table separator]
+          puts "Installing components: #{components.join(", ")}..."
+          system("npx shadcn@latest add #{components.join(" ")} --yes --overwrite")
+        end
+
+        puts "Project created successfully!"
+        puts "Run: cd #{name} && bundle install && nightingale run app.rb"
+      else
+        puts "Error: Frontend template not found at #{frontend_template}"
+      end
+    end
+
+    def self.run(script_path)
+      script_path = File.expand_path(script_path)
+      unless File.exist?(script_path)
+        puts "Error: Script not found: #{script_path}"
+        exit 1
+      end
+
+      puts "Starting Nightingale..."
+      puts "Script: #{script_path}"
+
+      # Start Backend (Sinatra)
+      server_pid = fork do
+        ENV["NIGHTINGALE_SCRIPT"] = script_path
+        # Suppress Sinatra startup logs if needed, or keep them
+        require "nightingale/server"
+        Nightingale::Server.run!
+      end
+
+      # Start Frontend (Vite)
+      # Check if we are in a project with a frontend folder
+      frontend_dir = File.join(Dir.pwd, "frontend")
+      vite_pid = nil
+
+      if File.directory?(frontend_dir)
+        puts "Starting Frontend (Vite)..."
+        vite_pid = fork do
+          Dir.chdir(frontend_dir)
+          exec "npm run dev"
+        end
+      else
+        # If no local frontend, maybe we should serve the gem's frontend?
+        # For now, warn.
+        puts "Warning: 'frontend' directory not found. UI might not load."
+      end
+
+      trap("INT") do
+        puts "\nStopping..."
+        Process.kill("TERM", server_pid)
+        Process.kill("TERM", vite_pid) if vite_pid
+        Process.wait(server_pid)
+        Process.wait(vite_pid) if vite_pid
+        exit
+      end
+
+      Process.wait(server_pid)
+    end
+  end
+end

data/lib/nightingale/dsl.rb

@@ -0,0 +1,74 @@
+# frozen_string_literal: true
+
+module Nightingale
+  module DSL
+    def self.included(base)
+      base.extend(ClassMethods)
+    end
+
+    module ClassMethods
+      def components
+        @components ||= []
+      end
+
+      def reset_components!
+        @components = []
+      end
+    end
+
+    def title(text)
+      Nightingale::Runner.current.add_component({ type: "title", props: { text: text } })
+    end
+
+    def markdown(text)
+      Nightingale::Runner.current.add_component({ type: "markdown", props: { content: text } })
+    end
+
+    def button(label, key: nil)
+      key ||= "button_#{label}"
+      # Check if this button was clicked in the current event
+      clicked = Nightingale::Runner.current.event_triggered?(key, "click")
+
+      Nightingale::Runner.current.add_component({
+                                                  type: "button",
+                                                  id: key,
+                                                  props: { label: label, value: clicked }
+                                                })
+
+      clicked
+    end
+
+    def slider(label, min:, max:, value: nil, step: 1, key: nil)
+      key ||= "slider_#{label}"
+      current_value = Nightingale::Runner.current.get_widget_value(key) || value || min
+
+      Nightingale::Runner.current.add_component({
+                                                  type: "slider",
+                                                  id: key,
+                                                  props: { label: label, min: min, max: max, value: current_value,
+                                                           step: step }
+                                                })
+
+      current_value
+    end
+
+    def dataframe(data, key: nil)
+      key ||= "dataframe_#{data.object_id}"
+      # data should be an array of hashes or similar
+      Nightingale::Runner.current.add_component({
+                                                  type: "dataframe",
+                                                  id: key,
+                                                  props: { data: data }
+                                                })
+    end
+
+    def session_state
+      Nightingale::Runner.current.session_state
+    end
+
+    # Layout helpers could go here (sidebar, etc.)
+    def sidebar(&block)
+      Nightingale::Runner.current.with_container("sidebar", &block)
+    end
+  end
+end

data/lib/nightingale/runner.rb

@@ -0,0 +1,79 @@
+# frozen_string_literal: true
+
+require "json"
+
+module Nightingale
+  class Runner
+    attr_reader :components, :session_state
+
+    def self.current
+      Thread.current[:nightingale_runner]
+    end
+
+    def initialize(script_path)
+      @script_path = script_path
+      @components = []
+      @session_state = {}
+      @widget_values = {}
+      @current_event = nil
+      @container_stack = []
+    end
+
+    def run(event = nil, widget_values = {})
+      @components = []
+      @current_event = event
+      @widget_values.merge!(widget_values) if widget_values
+
+      Thread.current[:nightingale_runner] = self
+
+      begin
+        # We load the script content and eval it
+        # This is a simple way to execute it.
+        # In a real app, we might want to use a separate process or more isolation.
+        content = File.read(@script_path)
+
+        # Create a context to evaluate in
+        context = Object.new
+        context.extend(Nightingale::DSL)
+
+        context.instance_eval(content, @script_path)
+      rescue StandardError => e
+        puts "Error running script: #{e.message}"
+        puts e.backtrace
+        add_component({ type: "error", props: { message: e.message, backtrace: e.backtrace } })
+      ensure
+        Thread.current[:nightingale_runner] = nil
+      end
+
+      @components
+    end
+
+    def add_component(component)
+      if @container_stack.any?
+        parent = @container_stack.last
+        parent[:children] ||= []
+        parent[:children] << component
+      else
+        @components << component
+      end
+    end
+
+    def with_container(type)
+      container = { type: type, props: {}, children: [] }
+      add_component(container)
+      @container_stack.push(container)
+      yield
+      @container_stack.pop
+    end
+
+    def get_widget_value(key)
+      @widget_values[key]
+    end
+
+    def event_triggered?(key, event_type)
+      return false unless @current_event
+
+      @current_event["id"] == key && @current_event["event"] == event_type
+    end
+  end
+end

data/lib/nightingale/server.rb

@@ -0,0 +1,104 @@
+# frozen_string_literal: true
+
+require "sinatra/base"
+require "faye/websocket"
+require "json"
+require "listen"
+
+module Nightingale
+  class Server < Sinatra::Base
+    set :server, "puma"
+    set :bind, "0.0.0.0"
+    set :port, 4567
+
+    # Store runners per session (connection)
+    # In a real app, we'd use a proper session store
+    @@runners = {}
+    @@connections = []
+
+    def self.run!
+      # Start file watcher
+      script_path = ENV["NIGHTINGALE_SCRIPT"]
+      if script_path && File.exist?(script_path)
+        puts "Watching #{script_path} for changes..."
+        listener = Listen.to(File.dirname(script_path),
+                             only: /#{File.basename(script_path)}$/) do |modified, added, removed|
+          puts "File changed: #{modified}"
+          # Trigger rerun for all connections
+          @@connections.each do |ws|
+            runner = @@runners[ws.object_id]
+            next unless runner
+
+            puts "Rerunning for connection #{ws.object_id}"
+            tree = runner.run
+            ws.send({ type: "render", components: tree }.to_json)
+          end
+        end
+        listener.start
+      end
+
+      super
+    end
+
+    get "/" do
+      "Nightingale Server Running. Connect via WebSocket at /ws"
+    end
+
+    get "/ws" do
+      if Faye::WebSocket.websocket?(env)
+        ws = Faye::WebSocket.new(env)
+
+        ws.on :open do |event|
+          puts "WebSocket connection open"
+          @@connections << ws
+
+          # Initialize runner for this connection
+          script_path = ENV["NIGHTINGALE_SCRIPT"]
+          runner = Nightingale::Runner.new(script_path)
+          @@runners[ws.object_id] = runner
+
+          # Initial run
+          tree = runner.run
+          ws.send({ type: "render", components: tree }.to_json)
+        end
+
+        ws.on :message do |event|
+          data = JSON.parse(event.data)
+          puts "Received message: #{data}"
+
+          if data["type"] == "event"
+            runner = @@runners[ws.object_id]
+            if runner
+              # Rerun with event
+              # We pass the widget value from the event if applicable
+              # But usually the frontend sends all widget values or we track them?
+              # For MVP, let's assume the event contains the value of the widget that changed.
+              # And maybe we need to sync other widget values?
+              # Streamlit sends all widget states.
+              # For MVP, let's assume we just update the specific widget value in the runner's state?
+              # Or we pass it to run.
+
+              widget_values = data["values"] || {}
+              widget_values[data["id"]] = data["value"] if data["id"] && data.key?("value")
+
+              tree = runner.run(data, widget_values)
+              ws.send({ type: "render", components: tree }.to_json)
+            end
+          end
+        end
+
+        ws.on :close do |event|
+          puts "WebSocket connection closed"
+          @@connections.delete(ws)
+          @@runners.delete(ws.object_id)
+          ws = nil
+        end
+
+        return ws.rack_response
+      else
+        # Fallback for non-WS requests
+        "WebSocket connection required"
+      end
+    end
+  end
+end

data/lib/nightingale/version.rb

@@ -0,0 +1,5 @@
+# frozen_string_literal: true
+
+module Nightingale
+  VERSION = "0.1.0"
+end

data/lib/nightingale.rb

@@ -0,0 +1,11 @@
+# frozen_string_literal: true
+
+require_relative "nightingale/version"
+require_relative "nightingale/cli"
+require_relative "nightingale/server"
+require_relative "nightingale/runner"
+require_relative "nightingale/dsl"
+
+module Nightingale
+  class Error < StandardError; end
+end