diff --git a/.github/workflows/go.yml b/.github/workflows/go.yml
index 7c6718b..8a7116d 100644
--- a/.github/workflows/go.yml
+++ b/.github/workflows/go.yml
@@ -33,9 +33,5 @@ jobs:
       with:
         go-version: '1.25'
 
-    - name: Build
-      run: |
-        go run mage.go generate
-
     - name: Test
       run: go test -v ./...
diff --git a/.github/workflows/python.yml b/.github/workflows/python.yml
index c7f505e..f2fd48c 100644
--- a/.github/workflows/python.yml
+++ b/.github/workflows/python.yml
@@ -47,10 +47,6 @@ jobs:
         with:
           python-version: ${{ matrix.python-version }}
 
-      - name: "Generate parser files"
-        run: |
-          ./generate.sh
-
       - name: Install dependencies
         run: |
           uv sync --all-extras --dev
diff --git a/g4/generate.go b/g4/generate.go
deleted file mode 100644
index 4f19c8d..0000000
--- a/g4/generate.go
+++ /dev/null
@@ -1,6 +0,0 @@
-// Copyright 2023 Felipe Zipitria
-// SPDX-License-Identifier: Apache-2.0
-
-package g4
-
-//go:generate ../generate.sh
diff --git a/generate.sh b/generate.sh
index 5cc5686..db986ab 100755
--- a/generate.sh
+++ b/generate.sh
@@ -1,13 +1,13 @@
 #!/bin/sh
-# Copyright 2023 Felipe Zipitria
+# Copyright 2025 Felipe Zipitria
 # SPDX-License-Identifier: Apache-2.0
 
 # This script is used to generate the parser files for the seclang DSL.
 # It is used by the pre-commit hook to ensure that the parser files are up to date.
 
 # Check if java is installed
-if ! command -v java >/dev/null 2>&1; then
-    echo "Java is not installed. Please install Java and try again."
+if ! command -v npx >/dev/null 2>&1; then
+    echo "Node is not installed. Please install nodejs and try again."
     exit 1
 fi
 
@@ -15,9 +15,5 @@ fi
 g4_files=$(find . -name "SecLangLexer.g4")
 g4_dir=$(dirname "$g4_files")
 
-# Change directory to g4
-cd "$g4_dir"
-
-alias antlr4='java -Xmx500M -cp "../lib/antlr-4.13.2-complete.jar:$CLASSPATH" org.antlr.v4.Tool'
-antlr4 -Dlanguage=Go -no-visitor -package parser -o ../parser *.g4
-antlr4 -Dlanguage=Python3 -no-visitor -package parser -o ../src/seclang_parser *.g4
+npx antlr-ng -Dlanguage=Go -p parser -o parser g4/*.g4
+npx antlr-ng -Dlanguage=Python3 -o src/seclang_parser g4/*.g4
diff --git a/lib/antlr-4.13.2-complete.jar b/lib/antlr-4.13.2-complete.jar
deleted file mode 100644
index 75bfcc3..0000000
Binary files a/lib/antlr-4.13.2-complete.jar and /dev/null differ
diff --git a/magefile.go b/magefile.go
index 6e93b8b..8c5fee5 100644
--- a/magefile.go
+++ b/magefile.go
@@ -108,7 +108,7 @@ func Coverage() error {
 }
 
 func Generate() error {
-	return sh.RunV("go", "generate", "./...")
+	return sh.RunV("./generate.sh")
 }
 
 // Doc runs godoc, access at http://localhost:6060
diff --git a/parser/seclang_lexer.go b/parser/seclang_lexer.go
index 71c3709..34658a3 100644
--- a/parser/seclang_lexer.go
+++ b/parser/seclang_lexer.go
@@ -1,5 +1,3 @@
-// Code generated from SecLangLexer.g4 by ANTLR 4.13.2. DO NOT EDIT.
-
 package parser
 
 import (
diff --git a/parser/seclang_parser.go b/parser/seclang_parser.go
index 015da9c..270e78a 100644
--- a/parser/seclang_parser.go
+++ b/parser/seclang_parser.go
@@ -1,5 +1,3 @@
-// Code generated from SecLangParser.g4 by ANTLR 4.13.2. DO NOT EDIT.
-
 package parser // SecLangParser
 import (
 	"fmt"
@@ -4085,12 +4083,12 @@ func (s *Update_target_rulesContext) ToStringTree(ruleNames []string, recog antl
 	return antlr.TreesStringTree(s, ruleNames, recog)
 }
 
-type Update_target_by_tagContext struct {
+type Update_target_by_idContext struct {
 	Update_target_rulesContext
 }
 
-func NewUpdate_target_by_tagContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Update_target_by_tagContext {
-	var p = new(Update_target_by_tagContext)
+func NewUpdate_target_by_idContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Update_target_by_idContext {
+	var p = new(Update_target_by_idContext)
 
 	InitEmptyUpdate_target_rulesContext(&p.Update_target_rulesContext)
 	p.parser = parser
@@ -4099,32 +4097,32 @@ func NewUpdate_target_by_tagContext(parser antlr.Parser, ctx antlr.ParserRuleCon
 	return p
 }
 
-func (s *Update_target_by_tagContext) GetRuleContext() antlr.RuleContext {
+func (s *Update_target_by_idContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *Update_target_by_tagContext) CONFIG_SEC_RULE_UPDATE_TARGET_BY_TAG() antlr.TerminalNode {
-	return s.GetToken(SecLangParserCONFIG_SEC_RULE_UPDATE_TARGET_BY_TAG, 0)
+func (s *Update_target_by_idContext) CONFIG_SEC_RULE_UPDATE_TARGET_BY_ID() antlr.TerminalNode {
+	return s.GetToken(SecLangParserCONFIG_SEC_RULE_UPDATE_TARGET_BY_ID, 0)
 }
 
-func (s *Update_target_by_tagContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *Update_target_by_idContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterUpdate_target_by_tag(s)
+		listenerT.EnterUpdate_target_by_id(s)
 	}
 }
 
-func (s *Update_target_by_tagContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *Update_target_by_idContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitUpdate_target_by_tag(s)
+		listenerT.ExitUpdate_target_by_id(s)
 	}
 }
 
-type Update_target_by_idContext struct {
+type Update_target_by_msgContext struct {
 	Update_target_rulesContext
 }
 
-func NewUpdate_target_by_idContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Update_target_by_idContext {
-	var p = new(Update_target_by_idContext)
+func NewUpdate_target_by_msgContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Update_target_by_msgContext {
+	var p = new(Update_target_by_msgContext)
 
 	InitEmptyUpdate_target_rulesContext(&p.Update_target_rulesContext)
 	p.parser = parser
@@ -4133,32 +4131,32 @@ func NewUpdate_target_by_idContext(parser antlr.Parser, ctx antlr.ParserRuleCont
 	return p
 }
 
-func (s *Update_target_by_idContext) GetRuleContext() antlr.RuleContext {
+func (s *Update_target_by_msgContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *Update_target_by_idContext) CONFIG_SEC_RULE_UPDATE_TARGET_BY_ID() antlr.TerminalNode {
-	return s.GetToken(SecLangParserCONFIG_SEC_RULE_UPDATE_TARGET_BY_ID, 0)
+func (s *Update_target_by_msgContext) CONFIG_SEC_RULE_UPDATE_TARGET_BY_MSG() antlr.TerminalNode {
+	return s.GetToken(SecLangParserCONFIG_SEC_RULE_UPDATE_TARGET_BY_MSG, 0)
 }
 
-func (s *Update_target_by_idContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *Update_target_by_msgContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterUpdate_target_by_id(s)
+		listenerT.EnterUpdate_target_by_msg(s)
 	}
 }
 
-func (s *Update_target_by_idContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *Update_target_by_msgContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitUpdate_target_by_id(s)
+		listenerT.ExitUpdate_target_by_msg(s)
 	}
 }
 
-type Update_target_by_msgContext struct {
+type Update_target_by_tagContext struct {
 	Update_target_rulesContext
 }
 
-func NewUpdate_target_by_msgContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Update_target_by_msgContext {
-	var p = new(Update_target_by_msgContext)
+func NewUpdate_target_by_tagContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *Update_target_by_tagContext {
+	var p = new(Update_target_by_tagContext)
 
 	InitEmptyUpdate_target_rulesContext(&p.Update_target_rulesContext)
 	p.parser = parser
@@ -4167,23 +4165,23 @@ func NewUpdate_target_by_msgContext(parser antlr.Parser, ctx antlr.ParserRuleCon
 	return p
 }
 
-func (s *Update_target_by_msgContext) GetRuleContext() antlr.RuleContext {
+func (s *Update_target_by_tagContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *Update_target_by_msgContext) CONFIG_SEC_RULE_UPDATE_TARGET_BY_MSG() antlr.TerminalNode {
-	return s.GetToken(SecLangParserCONFIG_SEC_RULE_UPDATE_TARGET_BY_MSG, 0)
+func (s *Update_target_by_tagContext) CONFIG_SEC_RULE_UPDATE_TARGET_BY_TAG() antlr.TerminalNode {
+	return s.GetToken(SecLangParserCONFIG_SEC_RULE_UPDATE_TARGET_BY_TAG, 0)
 }
 
-func (s *Update_target_by_msgContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *Update_target_by_tagContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterUpdate_target_by_msg(s)
+		listenerT.EnterUpdate_target_by_tag(s)
 	}
 }
 
-func (s *Update_target_by_msgContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *Update_target_by_tagContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitUpdate_target_by_msg(s)
+		listenerT.ExitUpdate_target_by_tag(s)
 	}
 }
 
@@ -9924,12 +9922,12 @@ func (s *Metadata_action_with_paramsContext) ToStringTree(ruleNames []string, re
 	return antlr.TreesStringTree(s, ruleNames, recog)
 }
 
-type ACTION_MATURITYContext struct {
+type ACTION_PHASEContext struct {
 	Metadata_action_with_paramsContext
 }
 
-func NewACTION_MATURITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_MATURITYContext {
-	var p = new(ACTION_MATURITYContext)
+func NewACTION_PHASEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_PHASEContext {
+	var p = new(ACTION_PHASEContext)
 
 	InitEmptyMetadata_action_with_paramsContext(&p.Metadata_action_with_paramsContext)
 	p.parser = parser
@@ -9938,32 +9936,32 @@ func NewACTION_MATURITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext)
 	return p
 }
 
-func (s *ACTION_MATURITYContext) GetRuleContext() antlr.RuleContext {
+func (s *ACTION_PHASEContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *ACTION_MATURITYContext) ACTION_MATURITY() antlr.TerminalNode {
-	return s.GetToken(SecLangParserACTION_MATURITY, 0)
+func (s *ACTION_PHASEContext) ACTION_PHASE() antlr.TerminalNode {
+	return s.GetToken(SecLangParserACTION_PHASE, 0)
 }
 
-func (s *ACTION_MATURITYContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_PHASEContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterACTION_MATURITY(s)
+		listenerT.EnterACTION_PHASE(s)
 	}
 }
 
-func (s *ACTION_MATURITYContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_PHASEContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitACTION_MATURITY(s)
+		listenerT.ExitACTION_PHASE(s)
 	}
 }
 
-type ACTION_REVContext struct {
+type ACTION_IDContext struct {
 	Metadata_action_with_paramsContext
 }
 
-func NewACTION_REVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_REVContext {
-	var p = new(ACTION_REVContext)
+func NewACTION_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_IDContext {
+	var p = new(ACTION_IDContext)
 
 	InitEmptyMetadata_action_with_paramsContext(&p.Metadata_action_with_paramsContext)
 	p.parser = parser
@@ -9972,32 +9970,32 @@ func NewACTION_REVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACT
 	return p
 }
 
-func (s *ACTION_REVContext) GetRuleContext() antlr.RuleContext {
+func (s *ACTION_IDContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *ACTION_REVContext) ACTION_REV() antlr.TerminalNode {
-	return s.GetToken(SecLangParserACTION_REV, 0)
+func (s *ACTION_IDContext) ACTION_ID() antlr.TerminalNode {
+	return s.GetToken(SecLangParserACTION_ID, 0)
 }
 
-func (s *ACTION_REVContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_IDContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterACTION_REV(s)
+		listenerT.EnterACTION_ID(s)
 	}
 }
 
-func (s *ACTION_REVContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_IDContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitACTION_REV(s)
+		listenerT.ExitACTION_ID(s)
 	}
 }
 
-type ACTION_VERContext struct {
+type ACTION_MATURITYContext struct {
 	Metadata_action_with_paramsContext
 }
 
-func NewACTION_VERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_VERContext {
-	var p = new(ACTION_VERContext)
+func NewACTION_MATURITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_MATURITYContext {
+	var p = new(ACTION_MATURITYContext)
 
 	InitEmptyMetadata_action_with_paramsContext(&p.Metadata_action_with_paramsContext)
 	p.parser = parser
@@ -10006,32 +10004,32 @@ func NewACTION_VERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACT
 	return p
 }
 
-func (s *ACTION_VERContext) GetRuleContext() antlr.RuleContext {
+func (s *ACTION_MATURITYContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *ACTION_VERContext) ACTION_VER() antlr.TerminalNode {
-	return s.GetToken(SecLangParserACTION_VER, 0)
+func (s *ACTION_MATURITYContext) ACTION_MATURITY() antlr.TerminalNode {
+	return s.GetToken(SecLangParserACTION_MATURITY, 0)
 }
 
-func (s *ACTION_VERContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_MATURITYContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterACTION_VER(s)
+		listenerT.EnterACTION_MATURITY(s)
 	}
 }
 
-func (s *ACTION_VERContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_MATURITYContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitACTION_VER(s)
+		listenerT.ExitACTION_MATURITY(s)
 	}
 }
 
-type ACTION_SEVERITYContext struct {
+type ACTION_MSGContext struct {
 	Metadata_action_with_paramsContext
 }
 
-func NewACTION_SEVERITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_SEVERITYContext {
-	var p = new(ACTION_SEVERITYContext)
+func NewACTION_MSGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_MSGContext {
+	var p = new(ACTION_MSGContext)
 
 	InitEmptyMetadata_action_with_paramsContext(&p.Metadata_action_with_paramsContext)
 	p.parser = parser
@@ -10040,32 +10038,32 @@ func NewACTION_SEVERITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext)
 	return p
 }
 
-func (s *ACTION_SEVERITYContext) GetRuleContext() antlr.RuleContext {
+func (s *ACTION_MSGContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *ACTION_SEVERITYContext) ACTION_SEVERITY() antlr.TerminalNode {
-	return s.GetToken(SecLangParserACTION_SEVERITY, 0)
+func (s *ACTION_MSGContext) ACTION_MSG() antlr.TerminalNode {
+	return s.GetToken(SecLangParserACTION_MSG, 0)
 }
 
-func (s *ACTION_SEVERITYContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_MSGContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterACTION_SEVERITY(s)
+		listenerT.EnterACTION_MSG(s)
 	}
 }
 
-func (s *ACTION_SEVERITYContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_MSGContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitACTION_SEVERITY(s)
+		listenerT.ExitACTION_MSG(s)
 	}
 }
 
-type ACTION_MSGContext struct {
+type ACTION_REVContext struct {
 	Metadata_action_with_paramsContext
 }
 
-func NewACTION_MSGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_MSGContext {
-	var p = new(ACTION_MSGContext)
+func NewACTION_REVContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_REVContext {
+	var p = new(ACTION_REVContext)
 
 	InitEmptyMetadata_action_with_paramsContext(&p.Metadata_action_with_paramsContext)
 	p.parser = parser
@@ -10074,32 +10072,32 @@ func NewACTION_MSGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACT
 	return p
 }
 
-func (s *ACTION_MSGContext) GetRuleContext() antlr.RuleContext {
+func (s *ACTION_REVContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *ACTION_MSGContext) ACTION_MSG() antlr.TerminalNode {
-	return s.GetToken(SecLangParserACTION_MSG, 0)
+func (s *ACTION_REVContext) ACTION_REV() antlr.TerminalNode {
+	return s.GetToken(SecLangParserACTION_REV, 0)
 }
 
-func (s *ACTION_MSGContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_REVContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterACTION_MSG(s)
+		listenerT.EnterACTION_REV(s)
 	}
 }
 
-func (s *ACTION_MSGContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_REVContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitACTION_MSG(s)
+		listenerT.ExitACTION_REV(s)
 	}
 }
 
-type ACTION_PHASEContext struct {
+type ACTION_SEVERITYContext struct {
 	Metadata_action_with_paramsContext
 }
 
-func NewACTION_PHASEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_PHASEContext {
-	var p = new(ACTION_PHASEContext)
+func NewACTION_SEVERITYContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_SEVERITYContext {
+	var p = new(ACTION_SEVERITYContext)
 
 	InitEmptyMetadata_action_with_paramsContext(&p.Metadata_action_with_paramsContext)
 	p.parser = parser
@@ -10108,32 +10106,32 @@ func NewACTION_PHASEContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *A
 	return p
 }
 
-func (s *ACTION_PHASEContext) GetRuleContext() antlr.RuleContext {
+func (s *ACTION_SEVERITYContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *ACTION_PHASEContext) ACTION_PHASE() antlr.TerminalNode {
-	return s.GetToken(SecLangParserACTION_PHASE, 0)
+func (s *ACTION_SEVERITYContext) ACTION_SEVERITY() antlr.TerminalNode {
+	return s.GetToken(SecLangParserACTION_SEVERITY, 0)
 }
 
-func (s *ACTION_PHASEContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_SEVERITYContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterACTION_PHASE(s)
+		listenerT.EnterACTION_SEVERITY(s)
 	}
 }
 
-func (s *ACTION_PHASEContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_SEVERITYContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitACTION_PHASE(s)
+		listenerT.ExitACTION_SEVERITY(s)
 	}
 }
 
-type ACTION_IDContext struct {
+type ACTION_TAGContext struct {
 	Metadata_action_with_paramsContext
 }
 
-func NewACTION_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_IDContext {
-	var p = new(ACTION_IDContext)
+func NewACTION_TAGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_TAGContext {
+	var p = new(ACTION_TAGContext)
 
 	InitEmptyMetadata_action_with_paramsContext(&p.Metadata_action_with_paramsContext)
 	p.parser = parser
@@ -10142,32 +10140,32 @@ func NewACTION_IDContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTI
 	return p
 }
 
-func (s *ACTION_IDContext) GetRuleContext() antlr.RuleContext {
+func (s *ACTION_TAGContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *ACTION_IDContext) ACTION_ID() antlr.TerminalNode {
-	return s.GetToken(SecLangParserACTION_ID, 0)
+func (s *ACTION_TAGContext) ACTION_TAG() antlr.TerminalNode {
+	return s.GetToken(SecLangParserACTION_TAG, 0)
 }
 
-func (s *ACTION_IDContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_TAGContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterACTION_ID(s)
+		listenerT.EnterACTION_TAG(s)
 	}
 }
 
-func (s *ACTION_IDContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_TAGContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitACTION_ID(s)
+		listenerT.ExitACTION_TAG(s)
 	}
 }
 
-type ACTION_TAGContext struct {
+type ACTION_VERContext struct {
 	Metadata_action_with_paramsContext
 }
 
-func NewACTION_TAGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_TAGContext {
-	var p = new(ACTION_TAGContext)
+func NewACTION_VERContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACTION_VERContext {
+	var p = new(ACTION_VERContext)
 
 	InitEmptyMetadata_action_with_paramsContext(&p.Metadata_action_with_paramsContext)
 	p.parser = parser
@@ -10176,23 +10174,23 @@ func NewACTION_TAGContext(parser antlr.Parser, ctx antlr.ParserRuleContext) *ACT
 	return p
 }
 
-func (s *ACTION_TAGContext) GetRuleContext() antlr.RuleContext {
+func (s *ACTION_VERContext) GetRuleContext() antlr.RuleContext {
 	return s
 }
 
-func (s *ACTION_TAGContext) ACTION_TAG() antlr.TerminalNode {
-	return s.GetToken(SecLangParserACTION_TAG, 0)
+func (s *ACTION_VERContext) ACTION_VER() antlr.TerminalNode {
+	return s.GetToken(SecLangParserACTION_VER, 0)
 }
 
-func (s *ACTION_TAGContext) EnterRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_VERContext) EnterRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.EnterACTION_TAG(s)
+		listenerT.EnterACTION_VER(s)
 	}
 }
 
-func (s *ACTION_TAGContext) ExitRule(listener antlr.ParseTreeListener) {
+func (s *ACTION_VERContext) ExitRule(listener antlr.ParseTreeListener) {
 	if listenerT, ok := listener.(SecLangParserListener); ok {
-		listenerT.ExitACTION_TAG(s)
+		listenerT.ExitACTION_VER(s)
 	}
 }
 
diff --git a/parser/seclangparser_base_listener.go b/parser/seclangparser_base_listener.go
index 350cad8..1177929 100644
--- a/parser/seclangparser_base_listener.go
+++ b/parser/seclangparser_base_listener.go
@@ -1,5 +1,3 @@
-// Code generated from SecLangParser.g4 by ANTLR 4.13.2. DO NOT EDIT.
-
 package parser // SecLangParser
 import "github.com/antlr4-go/antlr/v4"
 
diff --git a/parser/seclangparser_listener.go b/parser/seclangparser_listener.go
index b9899d4..f4e9110 100644
--- a/parser/seclangparser_listener.go
+++ b/parser/seclangparser_listener.go
@@ -1,5 +1,3 @@
-// Code generated from SecLangParser.g4 by ANTLR 4.13.2. DO NOT EDIT.
-
 package parser // SecLangParser
 import "github.com/antlr4-go/antlr/v4"
 
diff --git a/src/seclang_parser/SecLangLexer.py b/src/seclang_parser/SecLangLexer.py
index e64b414..e9719e1 100644
--- a/src/seclang_parser/SecLangLexer.py
+++ b/src/seclang_parser/SecLangLexer.py
@@ -1,7 +1,3 @@
-# Copyright 2025 OWASP CRS Project
-# SPDX-License-Identifier: Apache-2.0
-
-# Generated from SecLangLexer.g4 by ANTLR 4.13.2
 from antlr4 import *
 from io import StringIO
 import sys
diff --git a/src/seclang_parser/SecLangParser.py b/src/seclang_parser/SecLangParser.py
index ea18baf..555647a 100644
--- a/src/seclang_parser/SecLangParser.py
+++ b/src/seclang_parser/SecLangParser.py
@@ -1,7 +1,3 @@
-# Copyright 2025 OWASP CRS Project
-# SPDX-License-Identifier: Apache-2.0
-
-# Generated from SecLangParser.g4 by ANTLR 4.13.2
 # encoding: utf-8
 from antlr4 import *
 from io import StringIO
@@ -2215,24 +2211,6 @@ def copyFrom(self, ctx:ParserRuleContext):
 
 
 
-    class Update_target_by_tagContext(Update_target_rulesContext):
-
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Update_target_rulesContext
-            super().__init__(parser)
-            self.copyFrom(ctx)
-
-        def CONFIG_SEC_RULE_UPDATE_TARGET_BY_TAG(self):
-            return self.getToken(SecLangParser.CONFIG_SEC_RULE_UPDATE_TARGET_BY_TAG, 0)
-
-        def enterRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "enterUpdate_target_by_tag" ):
-                listener.enterUpdate_target_by_tag(self)
-
-        def exitRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "exitUpdate_target_by_tag" ):
-                listener.exitUpdate_target_by_tag(self)
-
-
     class Update_target_by_idContext(Update_target_rulesContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Update_target_rulesContext
@@ -2269,6 +2247,24 @@ def exitRule(self, listener:ParseTreeListener):
                 listener.exitUpdate_target_by_msg(self)
 
 
+    class Update_target_by_tagContext(Update_target_rulesContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Update_target_rulesContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def CONFIG_SEC_RULE_UPDATE_TARGET_BY_TAG(self):
+            return self.getToken(SecLangParser.CONFIG_SEC_RULE_UPDATE_TARGET_BY_TAG, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterUpdate_target_by_tag" ):
+                listener.enterUpdate_target_by_tag(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitUpdate_target_by_tag" ):
+                listener.exitUpdate_target_by_tag(self)
+
+
 
     def update_target_rules(self):
 
@@ -4792,76 +4788,58 @@ def copyFrom(self, ctx:ParserRuleContext):
 
 
 
-    class ACTION_MATURITYContext(Metadata_action_with_paramsContext):
-
-        def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Metadata_action_with_paramsContext
-            super().__init__(parser)
-            self.copyFrom(ctx)
-
-        def ACTION_MATURITY(self):
-            return self.getToken(SecLangParser.ACTION_MATURITY, 0)
-
-        def enterRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "enterACTION_MATURITY" ):
-                listener.enterACTION_MATURITY(self)
-
-        def exitRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "exitACTION_MATURITY" ):
-                listener.exitACTION_MATURITY(self)
-
-
-    class ACTION_REVContext(Metadata_action_with_paramsContext):
+    class ACTION_PHASEContext(Metadata_action_with_paramsContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Metadata_action_with_paramsContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def ACTION_REV(self):
-            return self.getToken(SecLangParser.ACTION_REV, 0)
+        def ACTION_PHASE(self):
+            return self.getToken(SecLangParser.ACTION_PHASE, 0)
 
         def enterRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "enterACTION_REV" ):
-                listener.enterACTION_REV(self)
+            if hasattr( listener, "enterACTION_PHASE" ):
+                listener.enterACTION_PHASE(self)
 
         def exitRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "exitACTION_REV" ):
-                listener.exitACTION_REV(self)
+            if hasattr( listener, "exitACTION_PHASE" ):
+                listener.exitACTION_PHASE(self)
 
 
-    class ACTION_VERContext(Metadata_action_with_paramsContext):
+    class ACTION_IDContext(Metadata_action_with_paramsContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Metadata_action_with_paramsContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def ACTION_VER(self):
-            return self.getToken(SecLangParser.ACTION_VER, 0)
+        def ACTION_ID(self):
+            return self.getToken(SecLangParser.ACTION_ID, 0)
 
         def enterRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "enterACTION_VER" ):
-                listener.enterACTION_VER(self)
+            if hasattr( listener, "enterACTION_ID" ):
+                listener.enterACTION_ID(self)
 
         def exitRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "exitACTION_VER" ):
-                listener.exitACTION_VER(self)
+            if hasattr( listener, "exitACTION_ID" ):
+                listener.exitACTION_ID(self)
 
 
-    class ACTION_SEVERITYContext(Metadata_action_with_paramsContext):
+    class ACTION_MATURITYContext(Metadata_action_with_paramsContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Metadata_action_with_paramsContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def ACTION_SEVERITY(self):
-            return self.getToken(SecLangParser.ACTION_SEVERITY, 0)
+        def ACTION_MATURITY(self):
+            return self.getToken(SecLangParser.ACTION_MATURITY, 0)
 
         def enterRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "enterACTION_SEVERITY" ):
-                listener.enterACTION_SEVERITY(self)
+            if hasattr( listener, "enterACTION_MATURITY" ):
+                listener.enterACTION_MATURITY(self)
 
         def exitRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "exitACTION_SEVERITY" ):
-                listener.exitACTION_SEVERITY(self)
+            if hasattr( listener, "exitACTION_MATURITY" ):
+                listener.exitACTION_MATURITY(self)
 
 
     class ACTION_MSGContext(Metadata_action_with_paramsContext):
@@ -4882,40 +4860,40 @@ def exitRule(self, listener:ParseTreeListener):
                 listener.exitACTION_MSG(self)
 
 
-    class ACTION_PHASEContext(Metadata_action_with_paramsContext):
+    class ACTION_REVContext(Metadata_action_with_paramsContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Metadata_action_with_paramsContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def ACTION_PHASE(self):
-            return self.getToken(SecLangParser.ACTION_PHASE, 0)
+        def ACTION_REV(self):
+            return self.getToken(SecLangParser.ACTION_REV, 0)
 
         def enterRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "enterACTION_PHASE" ):
-                listener.enterACTION_PHASE(self)
+            if hasattr( listener, "enterACTION_REV" ):
+                listener.enterACTION_REV(self)
 
         def exitRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "exitACTION_PHASE" ):
-                listener.exitACTION_PHASE(self)
+            if hasattr( listener, "exitACTION_REV" ):
+                listener.exitACTION_REV(self)
 
 
-    class ACTION_IDContext(Metadata_action_with_paramsContext):
+    class ACTION_SEVERITYContext(Metadata_action_with_paramsContext):
 
         def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Metadata_action_with_paramsContext
             super().__init__(parser)
             self.copyFrom(ctx)
 
-        def ACTION_ID(self):
-            return self.getToken(SecLangParser.ACTION_ID, 0)
+        def ACTION_SEVERITY(self):
+            return self.getToken(SecLangParser.ACTION_SEVERITY, 0)
 
         def enterRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "enterACTION_ID" ):
-                listener.enterACTION_ID(self)
+            if hasattr( listener, "enterACTION_SEVERITY" ):
+                listener.enterACTION_SEVERITY(self)
 
         def exitRule(self, listener:ParseTreeListener):
-            if hasattr( listener, "exitACTION_ID" ):
-                listener.exitACTION_ID(self)
+            if hasattr( listener, "exitACTION_SEVERITY" ):
+                listener.exitACTION_SEVERITY(self)
 
 
     class ACTION_TAGContext(Metadata_action_with_paramsContext):
@@ -4936,6 +4914,24 @@ def exitRule(self, listener:ParseTreeListener):
                 listener.exitACTION_TAG(self)
 
 
+    class ACTION_VERContext(Metadata_action_with_paramsContext):
+
+        def __init__(self, parser, ctx:ParserRuleContext): # actually a SecLangParser.Metadata_action_with_paramsContext
+            super().__init__(parser)
+            self.copyFrom(ctx)
+
+        def ACTION_VER(self):
+            return self.getToken(SecLangParser.ACTION_VER, 0)
+
+        def enterRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "enterACTION_VER" ):
+                listener.enterACTION_VER(self)
+
+        def exitRule(self, listener:ParseTreeListener):
+            if hasattr( listener, "exitACTION_VER" ):
+                listener.exitACTION_VER(self)
+
+
 
     def metadata_action_with_params(self):
 
diff --git a/src/seclang_parser/SecLangParserListener.py b/src/seclang_parser/SecLangParserListener.py
index 22c5b05..7e2e870 100644
--- a/src/seclang_parser/SecLangParserListener.py
+++ b/src/seclang_parser/SecLangParserListener.py
@@ -1,7 +1,3 @@
-# Copyright 2025 OWASP CRS Project
-# SPDX-License-Identifier: Apache-2.0
-
-# Generated from SecLangParser.g4 by ANTLR 4.13.2
 from antlr4 import *
 if "." in __name__:
     from .SecLangParser import SecLangParser