howzit 2.1.34 → 2.1.38

data/lib/howzit/script_support.rb

@@ -267,11 +267,30 @@ module Howzit
 
           # Log functions
           log() {
+            local report_mode=false
+            # Check for -r or --report flag
+            if [ "$1" = "-r" ] || [ "$1" = "--report" ]; then
+              report_mode=true
+              shift
+            fi
             local level="$1"
             shift
             local message="$*"
-            if [ -n "$HOWZIT_COMM_FILE" ]; then
+
+            if [ "$report_mode" = true ] && [ -n "$HOWZIT_COMM_FILE" ]; then
+              # Report mode: write to communication file
               echo "LOG:$level:$message" >> "$HOWZIT_COMM_FILE"
+            else
+              # Immediate mode: output with colors
+              local color=""
+              local reset="\\033[0m"
+              case "$level" in
+                info)  color="\\033[36m" ;;  # cyan
+                warn)  color="\\033[33m" ;;  # yellow
+                error) color="\\033[31m" ;;  # red
+                debug) color="\\033[2m"  ;;  # dim
+              esac
+              echo -e "${color}${message}${reset}" >&2
             fi
           }
 
@@ -306,11 +325,34 @@ module Howzit
           # Howzit helper functions for fish
 
           function log -d "Log a message at the specified level"
+            set report_mode false
+            # Check for -r or --report flag
+            if test "$argv[1]" = "-r"; or test "$argv[1]" = "--report"
+              set report_mode true
+              set -e argv[1]
+            end
             set level $argv[1]
             set -e argv[1]
             set message (string join " " $argv)
-            if test -n "$HOWZIT_COMM_FILE"
+
+            if test "$report_mode" = true; and test -n "$HOWZIT_COMM_FILE"
+              # Report mode: write to communication file
               echo "LOG:$level:$message" >> "$HOWZIT_COMM_FILE"
+            else
+              # Immediate mode: output with colors
+              set color ""
+              set reset "\\033[0m"
+              switch "$level"
+                case info
+                  set color "\\033[36m"  # cyan
+                case warn
+                  set color "\\033[33m"  # yellow
+                case error
+                  set color "\\033[31m"  # red
+                case debug
+                  set color "\\033[2m"   # dim
+              end
+              echo -e "$color$message$reset" >&2
             end
           end
 
@@ -362,30 +404,43 @@ module Howzit
               end
 
               class Logger
-                def info(message)
-                  log(:info, message)
+                def info(message, report: false)
+                  log(:info, message, report: report)
                 end
 
-                def warn(message)
-                  log(:warn, message)
+                def warn(message, report: false)
+                  log(:warn, message, report: report)
                 end
 
-                def error(message)
-                  log(:error, message)
+                def error(message, report: false)
+                  log(:error, message, report: report)
                 end
 
-                def debug(message)
-                  log(:debug, message)
+                def debug(message, report: false)
+                  log(:debug, message, report: report)
                 end
 
                 private
 
-                def log(level, message)
-                  comm_file = ENV['HOWZIT_COMM_FILE']
-                  return unless comm_file
+                def log(level, message, report: false)
+                  if report
+                    comm_file = ENV['HOWZIT_COMM_FILE']
+                    return unless comm_file
 
-                  File.open(comm_file, 'a') do |f|
-                    f.puts "LOG:#{level}:#{message}"
+                    File.open(comm_file, 'a') do |f|
+                      f.puts "LOG:#{level}:#{message}"
+                    end
+                  else
+                    # Immediate mode: output with colors
+                    color = case level
+                            when :info then "\033[36m"  # cyan
+                            when :warn then "\033[33m"  # yellow
+                            when :error then "\033[31m" # red
+                            when :debug then "\033[2m"   # dim
+                            else ""
+                            end
+                    reset = "\033[0m"
+                    $stderr.puts "#{color}#{message}#{reset}"
                   end
                 end
               end
@@ -419,25 +474,39 @@ module Howzit
           # Howzit helper module for Python
 
           import os
+          import sys
 
           class _Logger:
-              def _log(self, level, message):
-                  comm_file = os.environ.get('HOWZIT_COMM_FILE')
-                  if comm_file:
-                      with open(comm_file, 'a') as f:
-                          f.write(f"LOG:{level}:{message}\\n")
-
-              def info(self, message):
-                  self._log('info', message)
-
-              def warn(self, message):
-                  self._log('warn', message)
-
-              def error(self, message):
-                  self._log('error', message)
-
-              def debug(self, message):
-                  self._log('debug', message)
+              def _log(self, level, message, report=False):
+                  if report:
+                      comm_file = os.environ.get('HOWZIT_COMM_FILE')
+                      if comm_file:
+                          with open(comm_file, 'a') as f:
+                              f.write(f"LOG:{level}:{message}\\n")
+                  else:
+                      # Immediate mode: output with colors
+                      colors = {
+                          'info': '\\033[36m',   # cyan
+                          'warn': '\\033[33m',   # yellow
+                          'error': '\\033[31m',  # red
+                          'debug': '\\033[2m'    # dim
+                      }
+                      reset = '\\033[0m'
+                      color = colors.get(level, '')
+                      sys.stderr.write(f"{color}{message}{reset}\\n")
+                      sys.stderr.flush()
+
+              def info(self, message, report=False):
+                  self._log('info', message, report=report)
+
+              def warn(self, message, report=False):
+                  self._log('warn', message, report=report)
+
+              def error(self, message, report=False):
+                  self._log('error', message, report=report)
+
+              def debug(self, message, report=False):
+                  self._log('debug', message, report=report)
 
           class Howzit:
               logger = _Logger()
@@ -471,13 +540,33 @@ module Howzit
           use warnings;
 
           sub log {
+            my $report = 0;
+            # Check for -r or --report flag
+            if (@_ > 0 && ($_[0] eq '-r' || $_[0] eq '--report')) {
+              $report = 1;
+              shift;
+            }
             my ($level, $message) = @_;
-            my $comm_file = $ENV{'HOWZIT_COMM_FILE'};
-            return unless $comm_file;
 
-            open(my $fh, '>>', $comm_file) or return;
-            print $fh "LOG:$level:$message\\n";
-            close($fh);
+            if ($report) {
+              my $comm_file = $ENV{'HOWZIT_COMM_FILE'};
+              return unless $comm_file;
+
+              open(my $fh, '>>', $comm_file) or return;
+              print $fh "LOG:$level:$message\\n";
+              close($fh);
+            } else {
+              # Immediate mode: output with colors
+              my %colors = (
+                'info'  => "\\033[36m",  # cyan
+                'warn'  => "\\033[33m",  # yellow
+                'error' => "\\033[31m",  # red
+                'debug' => "\\033[2m"    # dim
+              );
+              my $reset = "\\033[0m";
+              my $color = $colors{$level} || '';
+              print STDERR "$color$message$reset\\n";
+            }
           }
 
           sub log_info { log('info', $_[0]); }
@@ -516,27 +605,40 @@ module Howzit
           const path = require('path');
 
           class Logger {
-            _log(level, message) {
-              const commFile = process.env.HOWZIT_COMM_FILE;
-              if (commFile) {
-                fs.appendFileSync(commFile, `LOG:${level}:${message}\\n`);
+            _log(level, message, report = false) {
+              if (report) {
+                const commFile = process.env.HOWZIT_COMM_FILE;
+                if (commFile) {
+                  fs.appendFileSync(commFile, `LOG:${level}:${message}\\n`);
+                }
+              } else {
+                // Immediate mode: output with colors
+                const colors = {
+                  'info': '\\033[36m',   // cyan
+                  'warn': '\\033[33m',   // yellow
+                  'error': '\\033[31m',  // red
+                  'debug': '\\033[2m'     // dim
+                };
+                const reset = '\\033[0m';
+                const color = colors[level] || '';
+                process.stderr.write(`${color}${message}${reset}\\n`);
               }
             }
 
-            info(message) {
-              this._log('info', message);
+            info(message, report = false) {
+              this._log('info', message, report);
             }
 
-            warn(message) {
-              this._log('warn', message);
+            warn(message, report = false) {
+              this._log('warn', message, report);
             }
 
-            error(message) {
-              this._log('error', message);
+            error(message, report = false) {
+              this._log('error', message, report);
             }
 
-            debug(message) {
-              this._log('debug', message);
+            debug(message, report = false) {
+              this._log('debug', message, report);
             }
           }
 

data/lib/howzit/stringutils.rb

@@ -91,7 +91,26 @@ module Howzit
     def build_note?
       return false if downcase !~ /^(howzit[^.]*|build[^.]+)/
 
-      return false if Howzit.config.should_ignore(self)
+      # Avoid recursion: only check ignore patterns if config is fully initialized
+      # and we're not in the middle of loading ignore patterns or initializing
+      begin
+        # Check if config exists without triggering initialization
+        return true unless Howzit.instance_variable_defined?(:@config)
+
+        config = Howzit.instance_variable_get(:@config)
+        return true unless config
+
+        # Check if config is initializing or loading ignore patterns to prevent recursion
+        return true if config.instance_variable_defined?(:@initializing) && config.instance_variable_get(:@initializing)
+        if config.instance_variable_defined?(:@loading_ignore_patterns) && config.instance_variable_get(:@loading_ignore_patterns)
+          return true
+        end
+
+        return false if config.respond_to?(:should_ignore) && config.should_ignore(self)
+      rescue StandardError
+        # If config access fails for any reason, skip the ignore check
+        # This prevents recursion and handles initialization edge cases
+      end
 
       true
     end

data/lib/howzit/task.rb

@@ -5,7 +5,7 @@ require 'English'
 module Howzit
   # Task object
   class Task
-    attr_reader :type, :title, :action, :arguments, :parent, :optional, :default, :last_status, :log_level
+    attr_reader :type, :title, :action, :arguments, :parent, :optional, :default, :last_status, :log_level, :source_file
 
     ##
     ## Initialize a Task object
@@ -21,6 +21,7 @@ module Howzit
     ## @option attributes :action [String] task action
     ## @option attributes :parent [String] title of nested (included) topic origin
     ## @option attributes :log_level [String] log level for this task (debug, info, warn, error)
+    ## @option attributes :source_file [String] path to the build note file this task came from
     def initialize(attributes, optional: false, default: true)
       @prefix = "{bw}\u{25B7}\u{25B7} {x}"
       # arrow = "{bw}\u{279F}{x}"
@@ -32,6 +33,9 @@ module Howzit
 
       @action = attributes[:action].render_arguments || nil
       @log_level = attributes[:log_level]
+      # Get source_file from parent topic if available, or from attributes
+      parent_obj = attributes[:parent]
+      @source_file = attributes[:source_file] || parent_obj&.source_file
 
       @optional = optional
       @default = default
@@ -68,7 +72,35 @@ module Howzit
       script = Tempfile.new('howzit_script')
       comm_file = ScriptComm.setup
       old_log_level = apply_log_level
+
+      # Get execution directory from source_file
+      # Only change directory in stack mode, and only if source_file is from a parent directory (not a template)
+      exec_dir = nil
+      if @source_file && Howzit.options[:stack]
+        expanded_source = File.expand_path(@source_file)
+        source_dir = File.dirname(expanded_source)
+
+        # Check if this is a template file - don't change directory for templates
+        is_template = false
+        if Howzit.config.respond_to?(:template_folder) && Howzit.config.template_folder
+          template_folder = File.expand_path(Howzit.config.template_folder)
+          is_template = expanded_source.start_with?(template_folder)
+        end
+
+        # Only change directory if not a template
+        exec_dir = source_dir unless is_template
+      end
+      original_dir = Dir.pwd
+
       begin
+        # Change to source file directory if available and different from current
+        # Only change if the directory exists and is actually different
+        if exec_dir && Dir.exist?(exec_dir)
+          expanded_exec_dir = File.expand_path(exec_dir)
+          expanded_original = File.expand_path(original_dir)
+          Dir.chdir(expanded_exec_dir) if expanded_exec_dir != expanded_original
+        end
+
         # Ensure support directory exists and install helpers
         ScriptSupport.ensure_support_dir
         ENV['HOWZIT_SUPPORT_DIR'] = ScriptSupport.support_dir
@@ -89,6 +121,12 @@ module Howzit
                 system(cmd)
               end
       ensure
+        # Restore original directory
+        if exec_dir && Dir.exist?(exec_dir)
+          expanded_exec_dir = File.expand_path(exec_dir)
+          expanded_original = File.expand_path(original_dir)
+          Dir.chdir(expanded_original) if expanded_exec_dir != expanded_original
+        end
         restore_log_level(old_log_level) if old_log_level
         script.close
         script.unlink
@@ -171,9 +209,43 @@ module Howzit
       ENV['HOWZIT_SCRIPTS'] = File.expand_path('~/.config/howzit/scripts')
       comm_file = ScriptComm.setup
       old_log_level = apply_log_level
+
+      # Get execution directory from source_file
+      # Only change directory in stack mode, and only if source_file is from a parent directory (not a template)
+      exec_dir = nil
+      if @source_file && Howzit.options[:stack]
+        expanded_source = File.expand_path(@source_file)
+        source_dir = File.dirname(expanded_source)
+
+        # Check if this is a template file - don't change directory for templates
+        is_template = false
+        if Howzit.config.respond_to?(:template_folder) && Howzit.config.template_folder
+          template_folder = File.expand_path(Howzit.config.template_folder)
+          is_template = expanded_source.start_with?(template_folder)
+        end
+
+        # Only change directory if not a template
+        exec_dir = source_dir unless is_template
+      end
+      original_dir = Dir.pwd
+
       begin
+        # Change to source file directory if available and different from current
+        # Only change if the directory exists and is actually different
+        if exec_dir && Dir.exist?(exec_dir)
+          expanded_exec_dir = File.expand_path(exec_dir)
+          expanded_original = File.expand_path(original_dir)
+          Dir.chdir(expanded_exec_dir) if expanded_exec_dir != expanded_original
+        end
+
         res = system(@action)
       ensure
+        # Restore original directory
+        if exec_dir && Dir.exist?(exec_dir)
+          expanded_exec_dir = File.expand_path(exec_dir)
+          expanded_original = File.expand_path(original_dir)
+          Dir.chdir(expanded_original) if expanded_exec_dir != expanded_original
+        end
         restore_log_level(old_log_level) if old_log_level
         # Process script communication
         ScriptComm.apply(comm_file) if comm_file
@@ -245,7 +317,13 @@ module Howzit
     ## @return     [String] List representation of the object.
     ##
     def to_list
-      "    * #{@type}: #{@title.preserve_escapes}"
+      # Highlight variables in title if parent topic has the method
+      display_title = if @parent.respond_to?(:highlight_variables)
+                        @parent.highlight_variables(@title.preserve_escapes)
+                      else
+                        @title.preserve_escapes
+                      end
+      "    * #{@type}: #{display_title}"
     end
   end
 end

data/lib/howzit/topic.rb

@@ -7,22 +7,24 @@ module Howzit
 
     attr_accessor :content
 
-    attr_reader :title, :tasks, :prereqs, :postreqs, :results, :named_args, :directives
+    attr_reader :title, :tasks, :prereqs, :postreqs, :results, :named_args, :directives, :arg_definitions, :source_file
 
     ##
     ## Initialize a topic object
     ##
-    ## @param      title    [String] The topic title
-    ## @param      content  [String] The raw topic content
-    ## @param      metadata [Hash] Optional metadata hash
+    ## @param      title       [String] The topic title
+    ## @param      content     [String] The raw topic content
+    ## @param      metadata    [Hash] Optional metadata hash
+    ## @param      source_file [String] Optional path to the build note file this topic came from
     ##
-    def initialize(title, content, metadata = nil)
+    def initialize(title, content, metadata = nil, source_file: nil)
       @title = title
       @content = content
       @parent = nil
       @nest_level = 0
       @named_args = {}
       @metadata = metadata
+      @source_file = source_file
       arguments
 
       @directives = parse_directives_with_conditionals
@@ -32,6 +34,7 @@ module Howzit
 
     # Get named arguments from title
     def arguments
+      @arg_definitions = []
       return unless @title =~ /\(.*?\) *$/
 
       a = @title.match(/\((?<args>.*?)\) *$/)
@@ -39,6 +42,8 @@ module Howzit
 
       args.each_with_index do |arg, idx|
         arg_name, default = arg.split(/:/).map(&:strip)
+        # Store original definition for display purposes
+        @arg_definitions << (default ? "#{arg_name}:#{default}" : arg_name)
 
         @named_args[arg_name] = if Howzit.arguments && Howzit.arguments.count >= idx + 1
                                   Howzit.arguments[idx]
@@ -277,7 +282,13 @@ module Howzit
 
       output = []
       if opt[:header]
-        output.push(@title.format_header)
+        # Include argument definitions in header if present
+        header_title = @title.dup
+        unless @arg_definitions.nil? || @arg_definitions.empty?
+          formatted_args = @arg_definitions.map { |arg| format_arg_definition(arg) }.join('{l}, '.c)
+          header_title += " {l}({x}#{formatted_args}{l}){x}".c
+        end
+        output.push(header_title.format_header)
         output.push('')
       end
       # Process conditional blocks first
@@ -302,11 +313,50 @@ module Howzit
           output.push("{bmK}\u{25B6} {bwK}#{title_code_block(Regexp.last_match.named_captures.symbolize_keys)}{x}".c)
         else
           l.wrap!(Howzit.options[:wrap]) if Howzit.options[:wrap].positive?
-          output.push(l)
+          # Highlight variable placeholders in content
+          output.push(highlight_variables(l))
         end
       end
       Howzit.named_arguments = @named_args
-      output.push('').map(&:render_arguments)
+      output.push('')
+    end
+
+    ##
+    ## Format an argument definition with syntax highlighting
+    ## Parentheses in blue, variable name in bright white, default in yellow
+    ##
+    ## @param      arg  [String] The argument definition (e.g., "var" or "var:default")
+    ##
+    ## @return     [String] Colorized argument definition
+    ##
+    def format_arg_definition(arg)
+      if arg.include?(':')
+        name, default = arg.split(':', 2)
+        "{bw}#{name}{l}:{y}#{default}{x}".c
+      else
+        "{bw}#{arg}{x}".c
+      end
+    end
+
+    ##
+    ## Highlight variable placeholders in content
+    ## Format: ${variable} or ${variable:default}
+    ## Dollar sign and braces in blue, variable name in bright white, default in yellow
+    ##
+    ## @param      text  [String] The text to process
+    ##
+    ## @return     [String] Text with highlighted variables
+    ##
+    def highlight_variables(text)
+      text.gsub(/\$\{([A-Za-z0-9_]+)(?::([^}]*))?\}/) do
+        var_name = Regexp.last_match(1)
+        default = Regexp.last_match(2)
+        if default
+          "{l}\\$\\{{bw}#{var_name}{l}:{y}#{default}{l}\\}{x}".c
+        else
+          "{l}\\$\\{{bw}#{var_name}{l}\\}{x}".c
+        end
+      end
     end
 
     include Comparable

data/lib/howzit/version.rb

@@ -3,5 +3,5 @@
 # Primary module for this gem.
 module Howzit
   # Current Howzit version.
-  VERSION = '2.1.34'
+  VERSION = '2.1.38'
 end