rosett-ai 1.6.1 → 1.8.1

checksums.yaml

@@ -1,7 +1,7 @@
 ---
 SHA256:
-  metadata.gz: 8968373d949471c707db0f0bddbe526797d8e47fdaf80b53a17d65e7fb5cb198
-  data.tar.gz: efdd68439a73eb12e2f6b503e999c2d0a40c9a6d9c73693da59cbacd9c3dab0c
+  metadata.gz: 95d279ef7cfbcfabd17980dcc444d353b1af0b31a1d19db87e5eaef99e59b4ab
+  data.tar.gz: a14e73c818b37af55a2eaefcb2ace6f9574a375faf24b8c30daa4aeabd8e5c57
 SHA512:
-  metadata.gz: 82e690044b7a4b4a54d3bf5f562c1b27711cb462b973d5d3d0078c3c0c8e84ca20dec5f027949d4cd0c233c26d4d321fe42cb20cfe9bb8ab7bdb068613c7787f
-  data.tar.gz: 4680e074d51a261d6ad4a98ce477d990b2ddf4187b30f90883c3d26cb86b1c7cfe6502b0ea7c5a07434f692111dc296e9a5eebb4ecb6477913bb5e6516b111d8
+  metadata.gz: edbf2bdf9f239fd288e55bf403b98dec1f5ae804a5437ff82e170c68a8f042b63426f19e4bade372e8425e3bda0b6d51d969cb47cf18c01d553f161feda0dc95
+  data.tar.gz: 9ac58d88a91de6ae5024c29acc51013ead935f63485adf128e07fdf9a2edd07d293e857023fc2c8bb8680114c62305e974709313ba2fa4bed1c77d54251a4a1b

data/CHANGELOG.md

@@ -6,6 +6,74 @@ Format follows [Keep a Changelog](https://keepachangelog.com/en/1.1.0/).
 
 ## [Unreleased]
 
+## [1.8.1] - 2026-08-14
+
+### Fixed
+
+- **`HookGenerator#format_regex` regex-literal syntax error** — the generator
+  previously emitted patterns as `/regex/` literals, which produced a Ruby
+  `SyntaxError` when the pattern contained a forward slash inside a character
+  class (e.g. `[^\/\s]`) or as a path separator (e.g. `\/tmp\/`). Ruby parses
+  the first unescaped `/` as the closing regex delimiter, silently breaking the
+  hook. Both the `pattern` and `path_scope` fields now emit `Regexp.new("...")`
+  calls, which are immune to delimiter conflicts. The bug affected every
+  generated hook since the feature was introduced; no hook had ever parsed
+  cleanly on the real rule set.
+
+- **`rai_hook_install` parse gate** — `HookInstallTool#write_hook` now runs
+  `ruby -c` on the generated script before writing it to disk. A `SyntaxError`
+  in the generated hook now raises immediately with a descriptive message rather
+  than silently installing a broken file.
+
+- **Regression specs** — `hook_generator_spec.rb` now includes contexts for
+  patterns containing `/` inside character classes and path separators, with
+  assertions that `RubyVM::InstructionSequence.compile` succeeds and that the
+  emitted form is `Regexp.new(...)` rather than a `/regex/` literal.
+
+## [1.8.0] - 2026-08-13
+
+### Added
+
+- **Enforcement rule scoping** — `HookGenerator` now supports per-rule `match_target`
+  (`path` | `content` | `both`) and optional `path_scope` (regex guard on the target
+  file path) fields in generated PreToolUse hook scripts. Rules without these fields
+  default to `both`, preserving backward-compatible behaviour. This eliminates false
+  positives that occurred when security-documentation text mentioning a forbidden
+  pattern triggered the rule against the file that documents it (e.g. sec_018
+  documentation was itself blocked).
+
+- **Behaviour schema v1.5.0** — two new optional fields on the `enforcement` block:
+  - `match_target: "path" | "content" | "both"` — selects which part of the tool
+    input the rule pattern is tested against. Default: `"both"`.
+  - `path_scope: string` — regex; when set, the rule only applies when the target
+    file path matches. Ignored when `match_target` is `"path"`.
+
+- **`Validator#build_valid_entry`** — passes `match_target` and `path_scope` through
+  to the rule hash so `HookGenerator` can embed them in RULES entries.
+
+## [1.7.0] - 2026-08-02
+
+### Added
+
+- **sec_018 bypass vector enforcement** — `HookGenerator` now uses per-tool field
+  extraction when generating PreToolUse hook scripts, preventing false positives
+  from raw hash stringification. Bash hooks match against the `command` field only;
+  Write/Edit hooks match against `file_path` and content fields. Covers all
+  sec_018 bypass vectors: `--no-verify`, `OVERCOMMIT_DISABLE`, `core.hooksPath=`,
+  `ruby-audit --ignore`, `SKIP=`, `allow_failure: true` on CI gates, and writes
+  to the bundler-audit ignore file. Red-team spec suite added covering all
+  known bypass vectors.
+
+## [1.6.2] - 2026-07-25
+
+### Fixed
+
+- **`raictl config compile` / `config show` crash with older engine plugins** — `resolve_config_compiler`
+  unconditionally passed `strict:` to the engine's `ConfigCompiler#initialize`, causing
+  `ArgumentError: unknown keyword: :strict` with engine gems whose constructor predates the
+  `strict` parameter. The fix introspects the constructor's parameter list at runtime and
+  only includes `strict:` when the engine supports it.
+
 ## [1.6.1] - 2026-07-23
 
 ### Security

data/conf/schemas/behaviour_schema.json

@@ -4,8 +4,8 @@
   "title": "NeatNerds Behaviour Configuration",
   "description": "Schema for validating behaviour configuration files used by the NeatNerds Code Companion (rosett-ai). Behaviour files define operational rules for Claude Code workflows.",
   "$comment": {
-    "date": "2026-07-19",
-    "version": "1.4.0",
+    "date": "2026-08-13",
+    "version": "1.5.0",
     "source": "rosett-ai",
     "compatible_claude_code_versions": [
       ">=0.1.0"
@@ -142,6 +142,16 @@
               "message": {
                 "type": "string",
                 "description": "Human-readable message shown when the rule triggers"
+              },
+              "match_target": {
+                "type": "string",
+                "enum": ["path", "content", "both"],
+                "description": "Which part of the tool input the pattern is tested against. Default: both (concatenated path + content, current behaviour)."
+              },
+              "path_scope": {
+                "type": "string",
+                "minLength": 1,
+                "description": "Regex string. When set, rule applies only when the target path matches. Ignored when match_target is path."
               }
             },
             "required": [

data/lib/rosett_ai/adopter/executor_resolver.rb

@@ -8,7 +8,7 @@ module RosettAi
     # Resolves the correct executor for an engine by reading its manifest
     # to determine the API type and constructor kwargs.
     #
-    # SDK-based engines (api_gem) receive api_key: and base_url:.
+    # SDK-based engines (api_gem) receive api_key: and base_url:. # gitleaks:allow
     # HTTP-based engines (api_type: http|openai_compatible) receive
     # endpoint: and model: from the manifest defaults.
     # CLI-based engines (api_type: cli) receive binary: from the manifest.

data/lib/rosett_ai/config/secret_resolver.rb

@@ -5,7 +5,7 @@
 
 module RosettAi
   module Config
-    # Resolves ${secret:backend:key} references in configuration values.
+    # Resolves ${secret:backend:key} references in configuration values. # gitleaks:allow
     #
     # Security constraints:
     # - NO regex anywhere — deterministic string parsing only (ReDoS prevention)

data/lib/rosett_ai/licensing/license_key.rb

@@ -16,7 +16,7 @@ module RosettAi
     # is held server-side and NEVER distributed.
     class LicenseKey
       # @return [String] Hex-encoded public key for license verification.
-      PUBLIC_KEY_HEX = '91f54336c0d42a7c88642b8d7f8bacab3adba4a4d633a33002fc15f676bfd8f0'
+      PUBLIC_KEY_HEX = '91f54336c0d42a7c88642b8d7f8bacab3adba4a4d633a33002fc15f676bfd8f0' # gitleaks:allow
       # @return [String] Prefix for rosett-ai license key strings.
       RAI_PREFIX = 'NNCC-'
       # @return [Integer] Days of grace period after license expiry.

data/lib/rosett_ai/mcp/enforcement/hook_generator.rb

@@ -163,17 +163,23 @@ module RosettAi
             "    pattern: #{format_regex(rule[:pattern])},",
             "    applies_to: [#{tools}],",
             "    action: :#{rule[:action]},",
+            "    match_target: :#{rule.fetch(:match_target, 'both')},",
+            "    path_scope: #{rule[:path_scope] ? format_regex(rule[:path_scope]) : 'nil'},",
             "    message: '#{msg}',",
             "    description: '#{desc}' }"
           ].join("\n  ")
         end
 
-        # Formats a pattern string as a Regexp literal for the generated script.
+        # Formats a pattern string as a Regexp.new() call for the generated script.
+        #
+        # Uses Regexp.new("...") rather than /regex/ literals to avoid delimiter
+        # conflicts when patterns contain forward slashes (e.g. inside character
+        # classes like [^\/\s] or path patterns like \/tmp\/).
         #
         # @param pattern [String]
         # @return [String]
         def format_regex(pattern)
-          "/#{pattern.gsub('/', '\\/')}/"
+          "Regexp.new(#{pattern.inspect})"
         end
 
         # Sanitizes a string for safe embedding in single-quoted Ruby strings.
@@ -189,6 +195,10 @@ module RosettAi
         # Generates the runtime enforcement logic body.
         # Uses non-interpolating heredoc — this code runs at hook time, not generation time.
         #
+        # Per-tool field extraction prevents false positives from raw hash stringification.
+        # Each tool has a known input schema; we extract only the fields that carry
+        # user-controlled content that sec_018 patterns must match against.
+        #
         # @return [String]
         def enforcement_body
           <<~'RUBY'
@@ -196,10 +206,39 @@ module RosettAi
 
             input = JSON.parse($stdin.read)
             tool_name = input['tool_name'].to_s
-            tool_input = input['tool_input'].to_s
+
+            target_path, target_content = case tool_name
+                                          when 'Bash'
+                                            cmd = input.dig('tool_input', 'command').to_s
+                                            [cmd, cmd]
+                                          when 'Write'
+                                            [input.dig('tool_input', 'file_path').to_s,
+                                             input.dig('tool_input', 'content').to_s]
+                                          when 'Edit'
+                                            content = [input.dig('tool_input', 'old_string'),
+                                                       input.dig('tool_input', 'new_string')].compact.join(' ')
+                                            [input.dig('tool_input', 'file_path').to_s, content]
+                                          when 'Agent'
+                                            ['', input.dig('tool_input', 'prompt').to_s]
+                                          else
+                                            raw = input.fetch('tool_input', '').to_s
+                                            [raw, raw]
+                                          end
 
             violations = RULES.select do |rule|
-              rule[:applies_to].include?(tool_name) && rule[:pattern].match?(tool_input)
+              next false unless rule[:applies_to].include?(tool_name)
+
+              if rule[:path_scope] && rule[:match_target] != :path
+                next false unless rule[:path_scope].match?(target_path)
+              end
+
+              match_text = case rule[:match_target]
+                           when :path    then target_path
+                           when :content then target_content
+                           else               "#{target_path} #{target_content}"
+                           end
+
+              rule[:pattern].match?(match_text)
             end
 
             exit 0 if violations.empty?
@@ -209,7 +248,6 @@ module RosettAi
                            "(P#{v[:priority]}, #{v[:action]}): #{v[:message].empty? ? v[:description] : v[:message]}"
             end
 
-            # Block if any violation has action :block
             blocked = violations.any? { |v| v[:action] == :block }
             exit(blocked ? 2 : 0)
           RUBY

data/lib/rosett_ai/mcp/enforcement/validator.rb

@@ -228,7 +228,9 @@ module RosettAi
           { rule_id: ctx.rule_id, behaviour: ctx.behaviour, type: 'enforceable',
             pattern: enforcement['pattern'], applies_to: enforcement['applies_to'],
             action: derive_action(enforcement, priority), message: enforcement['message'],
-            priority: priority, description: rule['description'].to_s.strip }
+            priority: priority, description: rule['description'].to_s.strip,
+            match_target: (enforcement['match_target'] || 'both').to_s,
+            path_scope: enforcement['path_scope'] }
         end
       end
     end

data/lib/rosett_ai/mcp/tools/hook_install_tool.rb

@@ -142,12 +142,26 @@ module RosettAi
 
         # @param hook_path [Pathname]
         # @param content [String]
+        # @raise [RuntimeError] if the generated script fails Ruby syntax check
         def write_hook(hook_path, content)
+          verify_ruby_syntax!(content)
           FileUtils.mkdir_p(hook_path.dirname)
           File.write(hook_path, content)
           FileUtils.chmod(0o755, hook_path)
         end
 
+        # Verifies generated hook content parses as valid Ruby before writing.
+        # Uses RubyVM::InstructionSequence.compile so no subprocess, Tempfile,
+        # or writable /tmp directory is required — the check works in CI containers.
+        #
+        # @param content [String] generated script content
+        # @raise [RuntimeError] if syntax check fails
+        def verify_ruby_syntax!(content)
+          RubyVM::InstructionSequence.compile(content)
+        rescue SyntaxError => e
+          raise "Generated hook failed Ruby syntax check: #{e.message}"
+        end
+
         # Registers the hook in settings.json if not already present.
         #
         # @param hook_path [Pathname]

data/lib/rosett_ai/retrofit/secret_detector.rb

@@ -6,7 +6,7 @@
 module RosettAi
   module Retrofit
     # Detects sensitive values in parsed configuration data and replaces
-    # them with ${secret:env:NAME} references.
+    # them with ${secret:env:NAME} references. # gitleaks:allow
     #
     # Recognises API keys, tokens, passwords, and other secrets by
     # key name patterns and value heuristics (length, entropy, prefixes).
@@ -69,7 +69,7 @@ module RosettAi
         env_name = full_key.upcase.gsub(/[^A-Z0-9]/, '_').squeeze('_')
         @warnings << "Sensitive value detected for '#{key}' — replaced with secret reference. " \
                      "Set #{env_name} in your environment."
-        "${secret:env:#{env_name}}"
+        "${secret:env:#{env_name}}" # gitleaks:allow
       end
 
       def sensitive?(key, value)

data/lib/rosett_ai/thor/tasks/config.rb

@@ -143,8 +143,12 @@ module RosettAi
           end
 
           secret_resolver = masking ? RosettAi::Config::MaskingSecretResolver.new : nil
-          plugin.config_compiler_class.new(simulate: simulate, secret_resolver: secret_resolver,
-                                           strict: strict)
+          klass = plugin.config_compiler_class
+          params = { simulate: simulate, secret_resolver: secret_resolver }
+          init_params = klass.instance_method(:initialize).parameters
+          supports_strict = init_params.any? { |type, name| name == :strict && [:key, :keyreq].include?(type) }
+          params[:strict] = strict if supports_strict
+          klass.new(**params)
         end
 
         def engine_hint(available, engine_name)

data/lib/rosett_ai/version.rb

@@ -5,5 +5,5 @@
 
 module RosettAi
   # @return [String] Current version of the rosett-ai gem.
-  VERSION = '1.6.1'
+  VERSION = '1.8.1'
 end

metadata

@@ -1,7 +1,7 @@
 --- !ruby/object:Gem::Specification
 name: rosett-ai
 version: !ruby/object:Gem::Version
-  version: 1.6.1
+  version: 1.8.1
 platform: ruby
 authors:
 - Hugo Antonio Sepulveda Manriquez