bash-classify 0.3.0__tar.gz → 0.4.0__tar.gz

{bash_classify-0.3.0 → bash_classify-0.4.0}/.claude-plugin/marketplace.json

@@ -8,7 +8,7 @@
     {
       "name": "bash-classify-hook",
       "description": "Auto-allows low-risk bash commands in Claude Code using bash-classify",
-      "version": "0.3.0",
+      "version": "0.4.0",
       "author": {
         "name": "Filip Procházka",
         "url": "https://github.com/fprochazka"

{bash_classify-0.3.0 → bash_classify-0.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bash-classify
-Version: 0.3.0
+Version: 0.4.0
 Summary: Classify bash commands as READONLY, WRITE, DANGEROUS, or UNKNOWN
 Project-URL: Homepage, https://github.com/fprochazka/bash-classify
 Project-URL: Repository, https://github.com/fprochazka/bash-classify

{bash_classify-0.3.0 → bash_classify-0.4.0}/SPEC.md

@@ -345,6 +345,48 @@ The database defines which options take values, so the parser knows whether `-n
 
 If the matched subcommand has `strict: true` (default), any unrecognized option makes the command `UNKNOWN`. If `strict: false`, unrecognized options are ignored (useful for commands with too many harmless flags to enumerate).
 
+### Subcommand matching modes
+
+The `subcommand_mode` field controls how positional arguments are matched against the subcommand dictionary. There are two modes:
+
+#### `hierarchical` (default)
+
+The default mode. Subcommands are matched as a greedy chain through nested subcommand dictionaries. Each matched subcommand narrows the context to its own subcommand dict.
+
+Example: `kubectl rollout status` matches `kubectl` → `rollout` → `status`, walking the tree.
+
+#### `match_all`
+
+Each positional argument is matched independently against the **same** top-level subcommand dictionary. This is designed for build tools like Maven and Gradle where multiple goals/tasks appear as positional arguments in any order.
+
+Example: `mvn clean install` matches both `clean` and `install` independently against `mvn`'s subcommand dict.
+
+**Classification/risk aggregation in `match_all` mode:**
+
+- The final classification is the **maximum severity** across all matched goals.
+- The final risk is the **maximum** across all matched goals' risks.
+- If any positional argument is **unrecognized** (not in the subcommand dict), the command's base classification and risk are included in the aggregation.
+- If **no goals match** (no positional args or all unrecognized), the command's base classification and risk apply.
+- Option overrides (e.g. `--dry-run`) take precedence over goal aggregation — they replace the classification as usual.
+- The `strict` mode only applies to **options** (flags starting with `-`), not to unrecognized positional arguments. Unrecognized goals do not cause UNKNOWN classification.
+
+```
+argv: ["mvn", "-B", "clean", "deploy"]
+
+Step 1: binary lookup → found "mvn" in database (subcommand_mode: match_all)
+Step 2: strip global options → none
+Step 3: subcommand matching (match_all mode)
+  - "-B" starts with "-" → passed to option classification
+  - "clean" found in subcommands → LOCAL_EFFECTS, risk LOW
+  - "deploy" found in subcommands → EXTERNAL_EFFECTS, risk MEDIUM (default)
+  - aggregate: classification = EXTERNAL_EFFECTS, risk = MEDIUM
+Step 4: option classification
+  - "-B" is a known option (no override)
+Step 5: classification
+  - aggregate classification: EXTERNAL_EFFECTS
+  - no option overrides → final: EXTERNAL_EFFECTS, risk: MEDIUM
+```
+
 ## Command Database Format
 
 YAML files, one per command or command family. Loaded from a `commands/` directory.
@@ -807,6 +849,7 @@ The `delegates_to` field defines how a command (or option like `find -exec`) han
 | `subcommands` | `map` | Nested subcommand definitions (recursive structure) |
 | `options` | `map` | Options that affect classification of this command/subcommand |
 | `strict` | `bool` | If `true` (default), unrecognized options yield `UNKNOWN` |
+| `subcommand_mode` | `enum` | How subcommands are matched: `hierarchical` (default, chained tree walk) or `match_all` (each positional arg matched independently) |
 | `delegates_to` | `object` | How this command delegates execution to an inner command (see delegation modes) |
 
 #### Option level

{bash_classify-0.3.0 → bash_classify-0.4.0}/coding-agent-plugins/claude-code/.claude-plugin/plugin.json

@@ -1,6 +1,6 @@
 {
   "name": "bash-classify-hook",
-  "version": "0.3.0",
+  "version": "0.4.0",
   "description": "Auto-allows low-risk bash commands in Claude Code using bash-classify",
   "author": {
     "name": "Filip Prochazka"

{bash_classify-0.3.0 → bash_classify-0.4.0}/docs/classification-guidance.md

@@ -410,7 +410,50 @@ subcommands:
       --dry-run: {takes_value: true, overrides: READONLY, risk: LOW}
 ```
 
-## 9. Common Patterns
+## 9. Subcommand Matching Modes
+
+### `subcommand_mode: hierarchical` (default)
+
+The default mode. Subcommands form a tree, and matching walks the tree greedily. This is correct for most CLI tools where subcommands are hierarchical (e.g. `kubectl rollout status`, `git stash list`).
+
+### `subcommand_mode: match_all`
+
+Use for build tools that accept multiple goals or tasks as positional arguments in any order. Each positional argument is matched independently against the same subcommand dictionary.
+
+```yaml
+# Maven accepts multiple lifecycle phases: mvn clean install
+command: mvn
+classification: LOCAL_EFFECTS
+strict: false
+subcommand_mode: match_all
+subcommands:
+  clean:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  compile:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  install:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  deploy:
+    classification: EXTERNAL_EFFECTS
+```
+
+**When to use `match_all`:**
+
+- Build tools that accept multiple goals/tasks (Maven, Gradle)
+- Commands where positional args are independent operations, not hierarchical nesting
+
+**How classification works:**
+
+- The final classification is the maximum severity across all matched goals
+- `mvn clean install` → both LOCAL_EFFECTS → final: LOCAL_EFFECTS
+- `mvn clean deploy` → LOCAL_EFFECTS + EXTERNAL_EFFECTS → final: EXTERNAL_EFFECTS
+- Unrecognized goals (e.g. custom Maven plugin goals like `some-plugin:goal`) fall back to the command's base classification and risk
+- Option overrides (e.g. `--dry-run`) still take precedence over goal aggregation
+
+## 10. Common Patterns
 
 | Pattern | Example | Classification |
 |---------|---------|---------------|

{bash_classify-0.3.0 → bash_classify-0.4.0}/schemas/command.schema.json

@@ -38,6 +38,9 @@
       "$ref": "#/$defs/SubcommandsMap",
       "description": "Nested subcommand definitions"
     },
+    "subcommand_mode": {
+      "$ref": "#/$defs/SubcommandMode"
+    },
     "delegates_to": {
       "$ref": "#/$defs/DelegationConfig"
     }
@@ -53,6 +56,11 @@
       "enum": ["LOW", "MEDIUM", "HIGH"],
       "description": "Risk level for a command or option override"
     },
+    "SubcommandMode": {
+      "type": "string",
+      "enum": ["hierarchical", "match_all"],
+      "description": "How subcommands are matched: hierarchical (chained tree walk, default) or match_all (each positional arg matched independently)"
+    },
     "DelegationConfig": {
       "type": "object",
       "required": ["mode"],
@@ -139,6 +147,9 @@
           "type": "boolean",
           "description": "If true (default), unrecognized options yield UNKNOWN"
         },
+        "subcommand_mode": {
+          "$ref": "#/$defs/SubcommandMode"
+        },
         "options": {
           "$ref": "#/$defs/OptionsMap"
         },

{bash_classify-0.3.0 → bash_classify-0.4.0}/src/bash_classify/commands/gradle.yaml

@@ -3,6 +3,40 @@ command: gradle
 description: "Gradle build tool"
 classification: LOCAL_EFFECTS
 strict: false
+subcommand_mode: match_all
+subcommands:
+  clean:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  build:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  test:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  assemble:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  check:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  jar:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  classes:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  compileJava:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  compileKotlin:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  publishToMavenLocal:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  publish:
+    classification: EXTERNAL_EFFECTS
 global_options:
   --help: {overrides: READONLY}
   -h: {overrides: READONLY}

{bash_classify-0.3.0 → bash_classify-0.4.0}/src/bash_classify/commands/gradlew.yaml

@@ -3,6 +3,40 @@ command: gradlew
 description: "Gradle wrapper"
 classification: LOCAL_EFFECTS
 strict: false
+subcommand_mode: match_all
+subcommands:
+  clean:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  build:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  test:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  assemble:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  check:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  jar:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  classes:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  compileJava:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  compileKotlin:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  publishToMavenLocal:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  publish:
+    classification: EXTERNAL_EFFECTS
 global_options:
   --help: {overrides: READONLY}
   -h: {overrides: READONLY}

{bash_classify-0.3.0 → bash_classify-0.4.0}/src/bash_classify/commands/mvn.yaml

@@ -3,6 +3,36 @@ command: mvn
 description: "Apache Maven build tool"
 classification: LOCAL_EFFECTS
 strict: false
+subcommand_mode: match_all
+subcommands:
+  clean:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  validate:
+    classification: READONLY
+  compile:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  test:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  test-compile:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  package:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  verify:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  install:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  site:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  deploy:
+    classification: EXTERNAL_EFFECTS
 global_options:
   --help: {overrides: READONLY}
   -h: {overrides: READONLY}

{bash_classify-0.3.0 → bash_classify-0.4.0}/src/bash_classify/commands/mvnw.yaml

@@ -3,6 +3,36 @@ command: mvnw
 description: "Apache Maven wrapper"
 classification: LOCAL_EFFECTS
 strict: false
+subcommand_mode: match_all
+subcommands:
+  clean:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  validate:
+    classification: READONLY
+  compile:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  test:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  test-compile:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  package:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  verify:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  install:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  site:
+    classification: LOCAL_EFFECTS
+    risk: LOW
+  deploy:
+    classification: EXTERNAL_EFFECTS
 global_options:
   --help: {overrides: READONLY}
   -h: {overrides: READONLY}

{bash_classify-0.3.0 → bash_classify-0.4.0}/src/bash_classify/commands/poetry.yaml

@@ -80,9 +80,11 @@ subcommands:
     subcommands:
       pytest:
         classification: LOCAL_EFFECTS
+        risk: LOW
         strict: false
       ruff:
         classification: LOCAL_EFFECTS
+        risk: LOW
         strict: false
       mypy:
         classification: READONLY

{bash_classify-0.3.0 → bash_classify-0.4.0}/src/bash_classify/commands/uv.yaml

@@ -14,9 +14,11 @@ subcommands:
     subcommands:
       pytest:
         classification: LOCAL_EFFECTS
+        risk: LOW
         strict: false
       ruff:
         classification: LOCAL_EFFECTS
+        risk: LOW
         strict: false
       mypy:
         classification: READONLY

{bash_classify-0.3.0 → bash_classify-0.4.0}/src/bash_classify/database.py

@@ -8,7 +8,7 @@ from pathlib import Path
 
 import yaml
 
-from .models import Classification, CommandDef, DelegationConfig, DelegationMode, OptionDef, Risk
+from .models import Classification, CommandDef, DelegationConfig, DelegationMode, OptionDef, Risk, SubcommandMode
 
 
 def get_default_commands_dir() -> Path:
@@ -177,6 +177,7 @@ def _parse_command_def(data: dict, command_name: str) -> CommandDef:
     subcommands = _parse_subcommands(data.get("subcommands", {}))
     delegates_to = _parse_delegation_config(data.get("delegates_to"))
     strict = data.get("strict", True)
+    subcommand_mode = _parse_subcommand_mode(data.get("subcommand_mode"))
 
     return CommandDef(
         command=command_name,
@@ -186,6 +187,7 @@ def _parse_command_def(data: dict, command_name: str) -> CommandDef:
         subcommands=subcommands,
         options=options,
         strict=strict,
+        subcommand_mode=subcommand_mode,
         delegates_to=delegates_to,
     )
 
@@ -204,6 +206,13 @@ def _parse_risk(value: str | None) -> Risk | None:
     return Risk(value)
 
 
+def _parse_subcommand_mode(value: str | None) -> SubcommandMode:
+    """Parse a subcommand_mode string into a SubcommandMode enum."""
+    if value is None:
+        return SubcommandMode.HIERARCHICAL
+    return SubcommandMode(value)
+
+
 def _parse_options(raw: dict | None) -> dict[str, OptionDef]:
     """Parse an options map, expanding aliases so each alias maps to the same OptionDef."""
     if not raw:

{bash_classify-0.3.0 → bash_classify-0.4.0}/src/bash_classify/matcher.py

@@ -15,6 +15,7 @@ from .models import (
     DelegationMode,
     InnerCommandResult,
     Risk,
+    SubcommandMode,
 )
 
 # Shell builtins that are special-cased (not from database)
@@ -101,7 +102,13 @@ def match_command(
     )
 
     # Step 3: Subcommand matching
-    matched_def, command_chain, remaining = _match_subcommand(remaining, command_def)
+    if command_def.subcommand_mode == SubcommandMode.MATCH_ALL:
+        matched_names, matched_defs, remaining = _match_all_subcommands(remaining, command_def)
+        matched_def = command_def  # options come from top-level
+        command_chain = matched_names
+    else:
+        matched_def, command_chain, remaining = _match_subcommand(remaining, command_def)
+        matched_defs = []  # not used in hierarchical mode
 
     # Step 4: Option classification
     (
@@ -194,6 +201,33 @@ def match_command(
                 elif all_overrides and not risk_explicitly_set:
                     final_risk = _default_risk(final_classification)
 
+    # Step 5b: For match_all, aggregate subcommand classifications/risks
+    if command_def.subcommand_mode == SubcommandMode.MATCH_ALL and matched_defs:
+        # Compute the aggregate classification/risk from all matched goals
+        agg_classification = Classification.READONLY
+        agg_risk = Risk.LOW
+        for sub_def in matched_defs:
+            sub_class = sub_def.classification or Classification.READONLY
+            sub_risk = sub_def.risk if sub_def.risk is not None else _default_risk(sub_class)
+            agg_classification = Classification.max_severity(agg_classification, sub_class)
+            agg_risk = Risk.max_severity(agg_risk, sub_risk)
+
+        # Check if there are unrecognized positional args (non-option tokens)
+        has_unrecognized_positional = any(not t.startswith("-") for t in remaining_positional)
+        if has_unrecognized_positional:
+            # Unrecognized goals: include base classification/risk in aggregation
+            agg_risk = Risk.max_severity(agg_risk, base_risk)
+
+        if all_overrides:
+            # Option overrides replace base classification; aggregate risk from goals
+            # but don't let goals override the option's classification decision
+            final_risk = Risk.max_severity(final_risk, agg_risk)
+        else:
+            # No option overrides: goals determine classification and risk
+            final_classification = Classification.max_severity(final_classification, agg_classification)
+            final_risk = agg_risk
+            classification_reason = f"base classification from rule {matched_rule}"
+
     # Strict mode: unrecognized options -> UNKNOWN
     if matched_def.strict and unknown_options:
         final_classification = Classification.max_severity(final_classification, Classification.UNKNOWN)
@@ -386,6 +420,36 @@ def _match_subcommand(
     return matched_def, command_chain, remaining
 
 
+def _match_all_subcommands(
+    argv: list[str],
+    command_def: CommandDef,
+) -> tuple[list[str], list[CommandDef], list[str]]:
+    """Match each positional arg independently against the same subcommand dict.
+
+    Used for commands like Maven and Gradle where multiple goals/tasks
+    appear as positional args in any order.
+
+    Returns (matched_names, matched_defs, remaining).
+    remaining includes both options and unrecognized positional args.
+    """
+    matched_names: list[str] = []
+    matched_defs: list[CommandDef] = []
+    remaining: list[str] = []
+
+    for token in argv:
+        if token.startswith("-"):
+            # Options pass through for _classify_options later
+            remaining.append(token)
+        elif token in command_def.subcommands:
+            matched_names.append(token)
+            matched_defs.append(command_def.subcommands[token])
+        else:
+            # Unrecognized goal — pass through as positional
+            remaining.append(token)
+
+    return matched_names, matched_defs, remaining
+
+
 def _classify_options(
     argv: list[str],
     command_def: CommandDef,

{bash_classify-0.3.0 → bash_classify-0.4.0}/src/bash_classify/models.py

@@ -68,6 +68,13 @@ _RISK_SEVERITY_ORDER: dict[Risk, int] = {
 }
 
 
+class SubcommandMode(enum.Enum):
+    """How subcommands are matched against positional arguments."""
+
+    HIERARCHICAL = "hierarchical"
+    MATCH_ALL = "match_all"
+
+
 class DelegationMode(enum.Enum):
     """How a command delegates execution to an inner command."""
 
@@ -134,6 +141,7 @@ class CommandDef:
     subcommands: dict[str, CommandDef] = field(default_factory=dict)
     options: dict[str, OptionDef] = field(default_factory=dict)
     strict: bool = True
+    subcommand_mode: SubcommandMode = SubcommandMode.HIERARCHICAL
     delegates_to: DelegationConfig | None = None
 
 

{bash_classify-0.3.0 → bash_classify-0.4.0}/tests/test_matcher.py

@@ -3,7 +3,7 @@
 from __future__ import annotations
 
 from bash_classify.matcher import _is_terminator, _strip_quotes, match_command
-from bash_classify.models import Classification, CommandDef, CommandInvocation, Risk
+from bash_classify.models import Classification, CommandDef, CommandInvocation, OptionDef, Risk, SubcommandMode
 
 
 def _make_invocation(argv: list[str]) -> CommandInvocation:
@@ -724,3 +724,77 @@ class TestRiskBuiltins:
     def test_test_builtin_low_risk(self, database: dict[str, CommandDef]) -> None:
         result = match_command(_make_invocation(["test", "-f", "file"]), database)
         assert result.risk == Risk.LOW
+
+
+class TestMatchAllSubcommandMode:
+    """Tests for subcommand_mode: match_all."""
+
+    def _make_match_all_command(self) -> CommandDef:
+        """Create a command with match_all subcommand mode for testing."""
+        return CommandDef(
+            command="builder",
+            classification=Classification.LOCAL_EFFECTS,
+            subcommand_mode=SubcommandMode.MATCH_ALL,
+            strict=False,
+            subcommands={
+                "clean": CommandDef(command="clean", classification=Classification.LOCAL_EFFECTS, risk=Risk.LOW),
+                "compile": CommandDef(command="compile", classification=Classification.LOCAL_EFFECTS, risk=Risk.LOW),
+                "test": CommandDef(command="test", classification=Classification.LOCAL_EFFECTS, risk=Risk.LOW),
+                "deploy": CommandDef(command="deploy", classification=Classification.EXTERNAL_EFFECTS),
+            },
+            options={
+                "-B": OptionDef(),
+                "--dry-run": OptionDef(overrides=Classification.READONLY),
+            },
+        )
+
+    def test_single_known_goal(self) -> None:
+        cmd_def = self._make_match_all_command()
+        database = {"builder": cmd_def}
+        result = match_command(_make_invocation(["builder", "clean"]), database)
+        assert result.classification == Classification.LOCAL_EFFECTS
+        assert result.risk == Risk.LOW
+        assert result.matched_rule == "builder.clean"
+
+    def test_multiple_known_goals_all_low(self) -> None:
+        cmd_def = self._make_match_all_command()
+        database = {"builder": cmd_def}
+        result = match_command(_make_invocation(["builder", "clean", "compile", "test"]), database)
+        assert result.classification == Classification.LOCAL_EFFECTS
+        assert result.risk == Risk.LOW
+        assert result.matched_rule == "builder.clean.compile.test"
+
+    def test_multiple_goals_max_classification(self) -> None:
+        cmd_def = self._make_match_all_command()
+        database = {"builder": cmd_def}
+        result = match_command(_make_invocation(["builder", "clean", "deploy"]), database)
+        assert result.classification == Classification.EXTERNAL_EFFECTS
+        assert result.risk == Risk.MEDIUM  # deploy has no explicit risk, EXTERNAL_EFFECTS defaults to MEDIUM
+
+    def test_unrecognized_goal_uses_base(self) -> None:
+        cmd_def = self._make_match_all_command()
+        database = {"builder": cmd_def}
+        result = match_command(_make_invocation(["builder", "clean", "custom-plugin:goal"]), database)
+        assert result.classification == Classification.LOCAL_EFFECTS
+        assert result.risk == Risk.MEDIUM  # base risk for LOCAL_EFFECTS
+
+    def test_no_goals_uses_base(self) -> None:
+        cmd_def = self._make_match_all_command()
+        database = {"builder": cmd_def}
+        result = match_command(_make_invocation(["builder"]), database)
+        assert result.classification == Classification.LOCAL_EFFECTS
+        assert result.risk == Risk.MEDIUM
+
+    def test_options_still_processed(self) -> None:
+        cmd_def = self._make_match_all_command()
+        database = {"builder": cmd_def}
+        result = match_command(_make_invocation(["builder", "-B", "clean", "compile"]), database)
+        assert result.classification == Classification.LOCAL_EFFECTS
+        assert result.risk == Risk.LOW
+
+    def test_option_override_works(self) -> None:
+        cmd_def = self._make_match_all_command()
+        database = {"builder": cmd_def}
+        result = match_command(_make_invocation(["builder", "--dry-run", "clean"]), database)
+        assert result.classification == Classification.READONLY
+        assert result.risk == Risk.LOW

{bash_classify-0.3.0 → bash_classify-0.4.0}/tests/test_models.py

@@ -2,7 +2,7 @@
 
 from __future__ import annotations
 
-from bash_classify.models import Classification, Risk
+from bash_classify.models import Classification, Risk, SubcommandMode
 
 
 class TestClassificationSeverity:
@@ -56,3 +56,9 @@ class TestRiskSeverity:
     def test_max_severity_all_three(self) -> None:
         result = Risk.max_severity(Risk.LOW, Risk.MEDIUM, Risk.HIGH)
         assert result == Risk.HIGH
+
+
+class TestSubcommandMode:
+    def test_subcommand_mode_values(self) -> None:
+        assert SubcommandMode.HIERARCHICAL.value == "hierarchical"
+        assert SubcommandMode.MATCH_ALL.value == "match_all"

{bash_classify-0.3.0 → bash_classify-0.4.0}/tests/test_real_world.py

@@ -433,3 +433,35 @@ class TestComplexRealWorld:
         """Git log piped to xargs for batch show."""
         result = classify_expression('git log --format="%H" | head -5 | xargs -I{} git show --stat {}', database)
         assert result.classification == Classification.READONLY
+
+
+class TestBuildTools:
+    """Build tools with match_all subcommand mode (Maven, Gradle)."""
+
+    def test_mvn_clean_install(self, database):
+        result = classify_expression("mvn clean install", database)
+        assert result.classification == Classification.LOCAL_EFFECTS
+        assert result.risk.value == "LOW"
+
+    def test_mvn_clean_deploy(self, database):
+        result = classify_expression("mvn clean deploy", database)
+        assert result.classification == Classification.EXTERNAL_EFFECTS
+        assert result.risk.value == "MEDIUM"
+
+    def test_mvn_custom_plugin_goal(self, database):
+        """Unrecognized goal falls back to command base classification."""
+        result = classify_expression("mvn clean some-plugin:goal", database)
+        assert result.classification == Classification.LOCAL_EFFECTS
+
+    def test_gradle_clean_build_test(self, database):
+        result = classify_expression("gradle clean build test", database)
+        assert result.classification == Classification.LOCAL_EFFECTS
+        assert result.risk.value == "LOW"
+
+    def test_gradle_publish(self, database):
+        result = classify_expression("gradle clean publish", database)
+        assert result.classification == Classification.EXTERNAL_EFFECTS
+
+    def test_gradle_dry_run(self, database):
+        result = classify_expression("gradle --dry-run clean build", database)
+        assert result.classification == Classification.READONLY