legionio 1.4.103 → 1.4.104

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: f036f54d059c1cdf1660a1ae08ed95b1fe97404d509123574508b9a6b36a1674
-  data.tar.gz: 616cacd65849dcdf73095f946df27c1afd9af68f9ee5f1b292ef53ee06f4554c
+  metadata.gz: 12afbe73936b06db9067ffa5e4fc445fe52c76687cd13aedbdb4b390a5515d7f
+  data.tar.gz: 960ca1400fe432d4ee1dbe51658afaa2e988982b178da080b8f20795bc42fa7e
 SHA512:
-  metadata.gz: 6681f51110762da3d76aa93b1e1ee2a92814c22e101842ef588f3a4d9492f585bdbf9bb4244df59c320c89d0dc992e17ba388b2ad56015a533fd7dec5411d378
-  data.tar.gz: ef6398f327e82cc91396d26fc855a6472eff22ee5f12e3ad225fbbbc06ee6df92912ef5c376dc9c0c838e0b6108bb3dbc7066f0372c820bb8e740d677fa70923
+  metadata.gz: 1ead15dbef330a1329a4b5a7b973235fa0d45d84b95cbaf5d7e0415ebde0d19154ef836fc6a84753780dd0270595bc087159a821b5cf06ed737b911a5707a054
+  data.tar.gz: 61edda120bb39a6868df425f5acb2ba39e602708c9959c5c4ad54ad8d6310ee15e72bbcb024f38907cc46136b5d28548af45e4752cb66df6b46b676fcb6a8a45

data/.rubocop.yml

@@ -43,6 +43,7 @@ Metrics/BlockLength:
     - 'lib/legion/cli/detect_command.rb'
     - 'lib/legion/cli/prompt_command.rb'
     - 'lib/legion/cli/image_command.rb'
+    - 'lib/legion/cli/notebook_command.rb'
     - 'lib/legion/api/acp.rb'
 
 Metrics/AbcSize:

data/CHANGELOG.md

@@ -1,5 +1,16 @@
 # Legion Changelog
 
+## [1.4.104] - 2026-03-21
+
+### Added
+- `legion notebook read PATH` — parse and display a .ipynb notebook with Rouge syntax highlighting
+- `legion notebook cells PATH` — list all cells with index numbers and line counts
+- `legion notebook export PATH --format md|script` — export notebook to markdown or Python script
+- `legion notebook create PATH --description "..."` — generate a new notebook from natural language via LLM (requires legion-llm)
+- `Legion::Notebook::Parser` — parse .ipynb JSON into structured data (metadata, kernel, language, cells with outputs)
+- `Legion::Notebook::Renderer` — display notebook cells in terminal with Rouge syntax highlighting
+- `Legion::Notebook::Generator` — generate notebooks from natural language; strips LLM markdown fences; validates .ipynb structure
+
 ## [1.4.103] - 2026-03-21
 
 ### Added

data/lib/legion/cli/notebook_command.rb

@@ -1,6 +1,10 @@
 # frozen_string_literal: true
 
 require 'thor'
+require 'json'
+require 'legion/cli/output'
+require 'legion/cli/error'
+require 'legion/cli/connection'
 
 module Legion
   module CLI
@@ -9,60 +13,207 @@ module Legion
         true
       end
 
-      desc 'read PATH', 'Read and display a Jupyter notebook'
+      class_option :json,       type: :boolean, default: false, desc: 'Output as JSON'
+      class_option :no_color,   type: :boolean, default: false, desc: 'Disable color output'
+      class_option :verbose,    type: :boolean, default: false, aliases: ['-V'], desc: 'Verbose logging'
+      class_option :config_dir, type: :string,                  desc: 'Config directory path'
+
+      desc 'read PATH', 'Parse and display a Jupyter notebook with syntax highlighting'
       def read(path)
-        nb = parse_notebook(path)
-        cells = nb['cells'] || []
-
-        cells.each_with_index do |cell, i|
-          type = cell['cell_type'] || 'unknown'
-          source = Array(cell['source']).join
-          say "--- Cell #{i + 1} [#{type}] ---", :yellow
-          say source
-          say ''
+        out = formatter
+        load_notebook(path, out)
+        color = !options[:no_color]
+
+        require 'legion/notebook/parser'
+        require 'legion/notebook/renderer'
+
+        parsed   = Legion::Notebook::Parser.parse(path)
+        rendered = Legion::Notebook::Renderer.render_notebook(parsed, color: color)
+
+        if options[:json]
+          out.json(cells: parsed[:cells].length, kernel: parsed[:kernel], path: path)
+        else
+          puts rendered
+          out.spacer
+          count = parsed[:cells].length
+          puts "#{count} cell#{'s' unless count == 1} total"
         end
-        say "#{cells.size} cells total", :green
+      rescue CLI::Error => e
+        formatter.error(e.message)
+        raise SystemExit, 1
       end
 
-      desc 'export PATH', 'Export notebook cells as markdown or script'
-      option :format, type: :string, default: 'markdown', enum: %w[markdown script]
-      def export(path)
-        nb = parse_notebook(path)
-        cells = nb['cells'] || []
-        lang = nb.dig('metadata', 'kernelspec', 'language') || 'python'
-
-        case options[:format]
-        when 'script'
-          cells.select { |c| c['cell_type'] == 'code' }.each do |cell|
-            say Array(cell['source']).join
-            say ''
+      desc 'cells PATH', 'List all cells with index numbers and types'
+      def cells(path)
+        out = formatter
+        load_notebook(path, out)
+
+        require 'legion/notebook/parser'
+
+        parsed = Legion::Notebook::Parser.parse(path)
+        color  = !options[:no_color]
+
+        if options[:json]
+          cell_list = parsed[:cells].each_with_index.map do |cell, i|
+            { index: i + 1, type: cell[:type], lines: cell[:source].lines.count }
           end
+          out.json(cells: cell_list, total: parsed[:cells].length)
         else
-          cells.each do |cell|
-            if cell['cell_type'] == 'code'
-              say "```#{lang}"
-              say Array(cell['source']).join
-              say '```'
+          parsed[:cells].each_with_index do |cell, i|
+            lines  = cell[:source].lines.count
+            plural = lines == 1 ? '' : 's'
+            label  = "  [#{(i + 1).to_s.rjust(2)}] #{cell[:type].to_s.ljust(8)}  #{lines} line#{plural}"
+            if color
+              type_color = cell[:type] == 'code' ? "\e[36m" : "\e[33m"
+              puts "#{type_color}#{label}\e[0m"
             else
-              say Array(cell['source']).join
+              puts label
             end
-            say ''
           end
+          out.spacer
+          puts "Total: #{parsed[:cells].length} cell#{'s' unless parsed[:cells].length == 1}"
         end
+      rescue CLI::Error => e
+        formatter.error(e.message)
+        raise SystemExit, 1
       end
 
-      private
+      desc 'export PATH', 'Export notebook to another format'
+      option :format, type: :string, default: 'md', enum: %w[md markdown script], desc: 'Export format: md or script'
+      option :output, type: :string, aliases: ['-o'], desc: 'Write to file instead of stdout'
+      def export(path)
+        out = formatter
+        load_notebook(path, out)
+
+        require 'legion/notebook/parser'
 
-      def parse_notebook(path)
-        unless File.exist?(path)
-          say "File not found: #{path}", :red
+        parsed = Legion::Notebook::Parser.parse(path)
+        lang   = parsed[:language]
+
+        content = case options[:format]
+                  when 'script'
+                    export_as_script(parsed[:cells], lang)
+                  else
+                    export_as_markdown(parsed[:cells], lang)
+                  end
+
+        if options[:output]
+          File.write(options[:output], content)
+          out.success("Exported to #{options[:output]}")
+        elsif options[:json]
+          out.json(content: content, format: options[:format], path: path)
+        else
+          puts content
+        end
+      rescue CLI::Error => e
+        formatter.error(e.message)
+        raise SystemExit, 1
+      end
+
+      desc 'create PATH', 'Generate a Jupyter notebook from a natural language description (requires legion-llm)'
+      option :description, type: :string, aliases: ['-d'], desc: 'What the notebook should do'
+      option :kernel,      type: :string, default: 'python3', desc: 'Kernel name (default: python3)'
+      option :model,       type: :string, aliases: ['-m'], desc: 'LLM model override'
+      option :provider,    type: :string, desc: 'LLM provider override'
+      def create(path)
+        out = formatter
+        setup_llm_connection(out)
+
+        require 'legion/notebook/generator'
+
+        description = options[:description]
+        if description.nil? || description.strip.empty?
+          out.error('--description is required for notebook creation')
           raise SystemExit, 1
         end
 
-        ::JSON.parse(File.read(path))
-      rescue ::JSON::ParserError => e
-        say "Invalid notebook format: #{e.message}", :red
+        out.success("Generating notebook: #{description}") unless options[:json]
+
+        notebook_data = Legion::Notebook::Generator.generate(
+          description: description,
+          kernel:      options[:kernel],
+          model:       options[:model],
+          provider:    options[:provider]
+        )
+
+        Legion::Notebook::Generator.write(path, notebook_data)
+        cell_count = Array(notebook_data['cells']).length
+
+        if options[:json]
+          out.json(path: path, cells: cell_count, kernel: options[:kernel])
+        else
+          out.success("Created #{path} (#{cell_count} cells)")
+        end
+      rescue ArgumentError, CLI::Error => e
+        formatter.error(e.message)
         raise SystemExit, 1
+      ensure
+        Connection.shutdown
+      end
+
+      no_commands do
+        def formatter
+          @formatter ||= Output::Formatter.new(
+            json:  options[:json],
+            color: !options[:no_color]
+          )
+        end
+
+        def setup_llm_connection(out)
+          Connection.config_dir = options[:config_dir] if options[:config_dir]
+          Connection.log_level  = options[:verbose] ? 'debug' : 'error'
+          Connection.ensure_llm
+        rescue CLI::Error => e
+          out.error(e.message)
+          raise SystemExit, 1
+        end
+
+        def load_notebook(path, out)
+          unless File.exist?(path)
+            out.error("File not found: #{path}")
+            raise SystemExit, 1
+          end
+
+          unless path.end_with?('.ipynb')
+            out.error("Expected a .ipynb file, got: #{File.basename(path)}")
+            raise SystemExit, 1
+          end
+
+          ::JSON.parse(File.read(path))
+        rescue ::JSON::ParserError => e
+          out.error("Invalid notebook JSON: #{e.message}")
+          raise SystemExit, 1
+        end
+
+        def export_as_markdown(cells, lang)
+          lines = []
+          cells.each do |cell|
+            if cell[:type] == 'code'
+              lines << "```#{lang}"
+              lines << cell[:source]
+              lines << '```'
+            else
+              lines << cell[:source]
+            end
+            lines << ''
+          end
+          lines.join("\n")
+        end
+
+        def export_as_script(cells, _lang)
+          lines = []
+          cells.each do |cell|
+            if cell[:type] == 'code'
+              lines << cell[:source]
+            else
+              cell[:source].each_line do |line|
+                lines << "# #{line.chomp}"
+              end
+            end
+            lines << ''
+          end
+          lines.join("\n")
+        end
       end
     end
   end

data/lib/legion/notebook/generator.rb

@@ -0,0 +1,81 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Legion
+  module Notebook
+    module Generator
+      NOTEBOOK_TEMPLATE = {
+        'nbformat'       => 4,
+        'nbformat_minor' => 5,
+        'metadata'       => {
+          'kernelspec'    => {
+            'display_name' => 'Python 3',
+            'language'     => 'python',
+            'name'         => 'python3'
+          },
+          'language_info' => {
+            'name' => 'python'
+          }
+        },
+        'cells'          => []
+      }.freeze
+
+      def self.generate(description:, kernel: 'python3', model: nil, provider: nil)
+        raise ArgumentError, 'legion-llm is required for notebook generation' unless defined?(Legion::LLM)
+
+        prompt = build_prompt(description, kernel)
+        response = call_llm(prompt, model: model, provider: provider)
+        parse_notebook_response(response)
+      end
+
+      def self.write(path, notebook_data)
+        File.write(path, ::JSON.pretty_generate(notebook_data))
+      end
+
+      def self.build_prompt(description, kernel)
+        <<~PROMPT
+          Generate a Jupyter notebook as valid JSON (.ipynb format) for the following task:
+
+          #{description}
+
+          Requirements:
+          - Use kernel: #{kernel}
+          - Include a markdown cell with a title and description at the top
+          - Include well-commented code cells
+          - Include markdown explanation cells between code sections
+          - Return ONLY the raw JSON, no markdown fences, no explanation
+
+          The JSON must follow the .ipynb format with these top-level keys:
+          nbformat, nbformat_minor, metadata, cells
+
+          Each cell must have: cell_type, metadata, source (array of strings), outputs (array), execution_count
+        PROMPT
+      end
+
+      def self.call_llm(prompt, model: nil, provider: nil)
+        kwargs = { messages: [{ role: 'user', content: prompt }] }
+        kwargs[:model]    = model           if model
+        kwargs[:provider] = provider.to_sym if provider
+        Legion::LLM.chat(**kwargs)
+      end
+
+      def self.parse_notebook_response(response)
+        content = response[:content].to_s.strip
+        # Strip markdown fences if the LLM wrapped the JSON
+        content = content.gsub(/\A```(?:json)?\n?/, '').gsub(/\n?```\z/, '').strip
+        data = ::JSON.parse(content)
+        validate_notebook!(data)
+        data
+      rescue ::JSON::ParserError => e
+        raise ArgumentError, "LLM returned invalid JSON: #{e.message}"
+      end
+
+      def self.validate_notebook!(data)
+        raise ArgumentError, 'Missing nbformat key'  unless data.key?('nbformat')
+        raise ArgumentError, 'Missing cells key'     unless data.key?('cells')
+        raise ArgumentError, 'cells must be an array' unless data['cells'].is_a?(Array)
+      end
+    end
+  end
+end

data/lib/legion/notebook/parser.rb

@@ -0,0 +1,44 @@
+# frozen_string_literal: true
+
+require 'json'
+
+module Legion
+  module Notebook
+    module Parser
+      def self.parse(path)
+        data = ::JSON.parse(File.read(path))
+        {
+          metadata: data['metadata'],
+          kernel:   data.dig('metadata', 'kernelspec', 'display_name'),
+          language: data.dig('metadata', 'kernelspec', 'language') || 'python',
+          cells:    Array(data['cells']).map { |c| parse_cell(c) }
+        }
+      end
+
+      def self.parse_cell(cell)
+        {
+          type:    cell['cell_type'],
+          source:  Array(cell['source']).join,
+          outputs: Array(cell.fetch('outputs', [])).map { |o| parse_output(o) }
+        }
+      end
+
+      def self.parse_output(output)
+        text = case output['output_type']
+               when 'execute_result', 'display_data'
+                 data = output.fetch('data', {})
+                 Array(data.fetch('text/plain', [])).join
+               when 'error'
+                 "#{output['ename']}: #{output['evalue']}"
+               else
+                 Array(output.fetch('text', [])).join
+               end
+
+        {
+          output_type: output['output_type'],
+          text:        text
+        }
+      end
+    end
+  end
+end

data/lib/legion/notebook/renderer.rb

@@ -0,0 +1,73 @@
+# frozen_string_literal: true
+
+module Legion
+  module Notebook
+    module Renderer
+      RESET  = "\e[0m"
+      BOLD   = "\e[1m"
+      DIM    = "\e[2m"
+      YELLOW = "\e[33m"
+      CYAN   = "\e[36m"
+      GREEN  = "\e[32m"
+      RED    = "\e[31m"
+      RULE   = "\e[2m#{'─' * 60}\e[0m".freeze
+
+      def self.render_notebook(notebook, color: true)
+        lines = []
+        kernel = notebook[:kernel]
+        lines << (color ? "#{BOLD}#{CYAN}Kernel: #{kernel}#{RESET}" : "Kernel: #{kernel}") if kernel
+
+        notebook[:cells].each_with_index do |cell, idx|
+          lines << ''
+          lines << render_cell_header(idx + 1, cell[:type], color)
+          lines << render_cell_source(cell, notebook[:language], color)
+          lines += render_cell_outputs(cell[:outputs], color) unless cell[:outputs].empty?
+        end
+
+        lines.join("\n")
+      end
+
+      def self.render_cell_header(index, type, color)
+        label = "[#{type}] Cell #{index}"
+        color ? "#{BOLD}#{YELLOW}#{label}#{RESET}" : label
+      end
+
+      def self.render_cell_source(cell, language, color)
+        return '' if cell[:source].empty?
+
+        if cell[:type] == 'code'
+          highlight(cell[:source], language, color)
+        else
+          color ? "#{DIM}#{cell[:source]}#{RESET}" : cell[:source]
+        end
+      end
+
+      def self.render_cell_outputs(outputs, color)
+        outputs.filter_map do |output|
+          next if output[:text].to_s.strip.empty?
+
+          prefix = color ? "#{DIM}  => " : '  => '
+          suffix = color ? RESET : ''
+          "#{prefix}#{output[:text].strip}#{suffix}"
+        end
+      end
+
+      def self.highlight(code, language, color)
+        return code unless color
+
+        begin
+          require 'rouge'
+          lexer     = Rouge::Lexer.find(language.to_s) || Rouge::Lexers::PlainText.new
+          formatter = Rouge::Formatters::Terminal256.new(Rouge::Themes::Monokai.new)
+          formatter.format(lexer.lex(code))
+        rescue LoadError
+          code
+        end
+      end
+
+      def self.rule(color)
+        color ? RULE : ('-' * 60)
+      end
+    end
+  end
+end

data/lib/legion/version.rb

@@ -1,5 +1,5 @@
 # frozen_string_literal: true
 
 module Legion
-  VERSION = '1.4.103'
+  VERSION = '1.4.104'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: legionio
 version: !ruby/object:Gem::Version
-  version: 1.4.103
+  version: 1.4.104
 platform: ruby
 authors:
 - Esity
@@ -609,6 +609,9 @@ files:
 - lib/legion/isolation.rb
 - lib/legion/lex.rb
 - lib/legion/metrics.rb
+- lib/legion/notebook/generator.rb
+- lib/legion/notebook/parser.rb
+- lib/legion/notebook/renderer.rb
 - lib/legion/process.rb
 - lib/legion/readiness.rb
 - lib/legion/registry.rb