[Refactor] Rule Generator V2

[colinthebomb1]

Overview

Migrate from RuleGenerator to RuleGeneratorV2, which runs the generalization pipeline directly on AST nodes.

Code Changes

• Create core/rule_generator_v2.py and migrate logic over.
  • AST-based pipeline: generalize_tables, generalize_columns, generalize_literals, generalize_subtrees, generalize_variables, generalize_branches.
  • Position-aware subtree replacement and parallel-attribute resync to keep JoinNode, CaseNode, and WhenThenNode consistent after mutation.
• JoinNode gains a first-class using attribute; parser/formatter support JOIN ... USING and NATURAL JOIN.
• rule_parser_v2.py placeholder substitution uses JoinNode attributes instead of child indexing.
• Create tests/test_rule_generator_v2.py.

Test

All tests pass in tests/test_rule_generator_v2.py.

[colinthebomb1]

rule_generator_v2.py Function Reference

There are 5 "steps" in the pipeline: Seed, Enumerate, Generalize, Search, and Render/Identify. Every function belongs to one of them, plus a shared Utilities group used across steps. This is a reference guide for PR reviews.

---

Utilities (used across all steps)

These are building blocks with no single owner — called by enumerating, generalizing, and rendering alike.

Function	What it does	When it's used
_walk(node)	Pre-order generator that yields every Node in the subtree rooted at node (including the node itself). Safe with None; non-Node children are skipped.	The "spine" of every traversal — used by _tables_of_ast, _literal_counts, columns, _replace_*_in_ast, etc. Anywhere we need to scan an AST.
varType(var)	Classifies an internal variable name (e.g. EV001, SV007) as ElementVariable, SetVariable, or None.	Render: in dereplaceVars, to pick the right <x> vs <<y>> marker.
_is_placeholder_name(name)	Returns True if a string is a generator-internal placeholder — matches __rv_x?__, __rvs_y?__, or bare x?/y? external names.	Enumerate: filters out already-variablized identifiers when scanning for concrete tables/columns/literals.
_suffix_int(value, prefix)	Strips prefix from value and returns the trailing integer (or None if not numeric).	Generalize: used by _find_next_*_variable to find the next free index.
_node_is_fully_variablized_column(node)	True when a ColumnNode's name is a placeholder and its parent_alias (if any) is also a placeholder.	Enumerate: gates whether a ColumnNode is a valid subtree candidate or branch leaf.
_PLACEHOLDER_PREFIXES	Constant ("x", "y") — the external-name prefixes used in mapping keys.	Used inside _is_placeholder_name.
RuleGeneralizations	Constant tuple of the six generalize_* method names.	Drives the fixed-point loop in generate_general_rule.

---

Step 1 — Seed

Goal: turn a (q0, q1) example into an initial un-generalized rule dict, and validate that both halves parse cleanly.

Public seed entry points

Function	What it does	When it's used
initialize_seed_rule(q0, q1)	Parses both sides via RuleParserV2, snapshots the source ASTs/SQL, and returns a fresh rule dict carrying pattern, rewrite, pattern_ast, rewrite_ast, mapping, and empty constraints/actions.	Public API. Called by recommend_simple_rules, generate_rule_graph, generate_general_rule — every entry point starts here.
parse_validate(pattern, rewrite)	Validates a (pattern, rewrite) rule pair. Returns (ok, message, error_index). Reports bracket mismatches, parser errors on either side, and rejects rules whose rewrite uses a variable that never appears in the pattern.	Public API. Called by callers editing rules in the UI.
parse_validate_single(query)	Validates a standalone rule query (used when only one half is being edited). Same return shape as parse_validate.	Public API.

Validation helpers (used only inside parse_validate*)

Function	What it does	When it's used
_parse_validate_impl(pattern, rewrite)	Shared implementation behind both public validators. Runs bracket check → spelling check using Levenshtein distance against SELECT/FROM/WHERE → variable substitution → parser validation → error-index remapping.	Both public validate entry points.
_rule_fragment_error_index(...)	Translates a parser-reported character offset from wrapped, substituted SQL back to an offset in the original rule fragment. Accounts for the synthetic scope prefix like SELECT * FROM t WHERE and internal variable token length differences.	Inside _parse_validate_impl when the parser raises with a character index.
_internal_variable_token_length_delta(internal_name)	Returns the character-count difference between the parser-safe internal variable token, such as EV001 or SV001, and the shorter display token used when reporting errors, such as V001 or VL001. Keeps reported error indices aligned with the user-facing rule text.	Inside _rule_fragment_error_index.
_lev_distance(a, b)	Recursive Levenshtein distance. Used to flag near-misses on SELECT/FROM/WHERE keywords.	Inside _parse_validate_impl.

---

Step 2 — Enumerate

Goal: given a rule, find every concrete thing inside its ASTs that could be generalized in this pass — tables, columns, literals, subtrees, variable-lists, and droppable branches. Each enumerator returns a list of "candidates"; Step 3 then applies one transformation per candidate.

Public enumerators

Function	What it does	When it's used
tables(p_ast, r_ast)	Returns deduped {"value", "name"} descriptors for every concrete (non-placeholder) table reference seen across both ASTs. Order: pattern first appearances, then rewrite-side aliases not already seen.	Generalize: feeds variablize_tables and generalize_tables.
columns(p_ast, r_ast)	Returns the deterministic, sorted set of un-variablized column names in the pattern. Variable-named and placeholder columns are excluded. r_ast is accepted for v1 parity but ignored.	Generalize: feeds variablize_columns and generalize_columns.
literals(p_ast, r_ast)	Returns literals worth variabilizing: any literal that recurs more than once on either side, plus any literal that appears on both sides.	Generalize: feeds variablize_literals and generalize_literals.
subtrees(p_ast, r_ast)	Returns subtrees that appear (structurally equal) in both pattern and rewrite, eligible to share an element variable. Pairs are matched first-fit between the two sides' candidate lists.	Generalize: feeds variablize_subtrees and generalize_subtrees.
variable_lists(p_ast, r_ast)	Returns element-variable name lists that exist on both sides (intersected pairwise). Each returned list is the intersection of one pattern-side AND/SELECT chain with the first matching rewrite-side chain.	Generalize: feeds merge_variables and generalize_variables.
branches(p_ast, r_ast)	Returns branch descriptors (clauses, AND/OR conjuncts, eq-RHS singletons) that exist on both sides and are fully variablized. Each entry is a {"key", "value"} dict suitable for drop_branch. Pairs are matched first-fit.	Generalize: feeds drop_branches and generalize_branches.
numberOfVariables(rule)	Returns the count of declared variables in rule['mapping'].	Search: tie-breaker in recommend_simple_rules when picking the simplest candidate among equivalents.

Per-AST collectors (single-side helpers)

Function	What it does	When it's used
_tables_of_ast(ast)	Walks ast and returns {"value", "name"} dicts for every concrete TableNode. Tables whose name or alias is itself a placeholder are skipped.	Called twice by tables (once per side). Also used by _is_branch_node to check if a subtree is fully variablized.
_literal_counts(ast)	Counts how often each literal value appears in ast. String literals are normalized by stripping % so 'foo%' and 'foo' collapse together; placeholder strings are ignored.	Called twice by literals (once per side). Also used by _is_branch_node.
_variable_lists_of_ast(ast)	Collects element-variable name lists from positions where v1 wraps a variable list: SELECT items, top-most AND chains (flattened), single-WHERE predicates, LIMIT, JOIN ON. AND chains are flattened across their full left-associative depth so a AND b AND c yields a single 3-name list.	Called twice by variable_lists. Also used by _is_branch_node.
_subtrees_of_ast(ast)	Returns deep copies of every fully-variablized subtree inside ast. A subtree is included only if _is_subtree_candidate accepts it for its parent context, and duplicates are de-duped by deparsed key (with _structural_key as fallback).	Called twice by subtrees.
_branch_entries_of_ast(ast)	Enumerates (public_descriptor, internal_target) pairs for every branch in ast that branches could potentially drop. Handles full queries (per-clause), AND/OR chains (per-conjunct), and equality RHS singletons.	Called twice by branches.

Subtree / branch predicates

Function	What it does	When it's used
_is_subtree_candidate(node, parent)	Position-aware "is this a replaceable subtree?" check. Mirrors v1's isSubtree: column/literal nodes only qualify in SELECT/GROUP BY/ORDER BY positions; set-variable nodes qualify under SELECT, single-WHERE, single-WHEN, or OR-chain parents; otherwise must have ≥1 variabilized child and no un-variabilized leaves.	Inside _subtrees_of_ast and _replace_subtree_in_ast.
_is_branch_clause(key, clause)	"Can this clause be dropped given its key (select, from, where, …)?"	Inside _branch_entries_of_ast.
_is_branch_node(node)	"Is this subtree fully variablized — no concrete tables, columns, literals, or variable lists left?"	Inside _branch_entries_of_ast and _is_branch_clause.
_branch_values_match(pb, rb, pb_target, rb_target)	True when two branch descriptors have the same key and their internal targets compare equal.	Inside branches, when matching pattern-side to rewrite-side.
_branch_targets_match(pb_target, rb_target)	Compares two branch targets, falling back to deparsed-string equality for Node instances that don't compare equal structurally.	Inside _branch_values_match.

---

Step 3 — Generalize

Goal: apply one or more transformations to a rule, producing new (more general) rules. Three flavors of API, layered:

3a. Singular — variablize_table, variablize_column, etc. — applies one substitution and returns one new rule.
3b. Plural — variablize_tables, variablize_columns, etc. — returns one new rule per candidate from Step 2.
3c. One-pass — generalize_tables, generalize_columns, etc. — applies all candidates in a single iteration and returns one rule.

3a — Singular transformations

Function	What it does	When it's used
variablize_table(rule, table)	Returns a new rule where the named table (and its qualified column refs) is replaced by a fresh element variable. table is a {"value", "name"} descriptor from tables.	Called by variablize_tables and generalize_tables.
variablize_column(rule, column)	Returns a new rule where every occurrence of column (in both ASTs) is replaced by a fresh element variable. Quirk: also captures bare * in non-DISTINCT SELECT, so the first column variabilized shares its variable with *.	Called by variablize_columns and generalize_columns.
variablize_literal(rule, literal)	Returns a new rule where every occurrence of literal (in both ASTs) is replaced by a fresh element variable. String literals preserve surrounding % LIKE wildcards.	Called by variablize_literals and generalize_literals.
variablize_subtree(rule, subtree)	Returns a new rule where every occurrence of subtree (in both ASTs) is replaced by a fresh element variable.	Called by variablize_subtrees and generalize_subtrees.
merge_variable_list(rule, variable_list)	Returns a new rule where the given element variables are collapsed into a single set variable <<y?>>.	Called by merge_variables, generalize_variables, and recommend_simple_rules.
drop_branch(rule, branch)	Returns a new rule with branch removed from both pattern and rewrite ASTs. branch is a descriptor produced by branches.	Called by drop_branches and generalize_branches.

3b — Plural (one child rule per candidate)

Function	What it does	When it's used
variablize_tables(rule)	One child rule per table replaceable with a fresh element variable.	generate_rule_graph, _recommendation_candidates.
variablize_columns(rule)	One child rule per column replaceable with a fresh element variable.	Same as above.
variablize_literals(rule)	One child rule per literal replaceable with a fresh element variable.	Same as above.
variablize_subtrees(rule)	One child rule per subtree shared by pattern and rewrite that can be collapsed into an element variable.	Same as above.
merge_variables(rule)	One child rule per element-variable list collapsible into a single set variable.	Same as above.
drop_branches(rule)	One child rule per droppable branch.	Same as above.

3c — One-pass generalization

Function	What it does	When it's used
generalize_tables(rule)	Walks every candidate from tables and applies variablize_table repeatedly. Returns a fresh dict; input is not mutated.	Called by generate_general_rule in its fixed-point loop.
generalize_columns(rule)	Same pattern, for columns.	Same as above.
generalize_literals(rule)	Same pattern, for literals.	Same as above.
generalize_subtrees(rule)	Same pattern, for shared subtrees.	Same as above.
generalize_variables(rule)	Same pattern, for mergeable element-variable lists. Skips empty lists.	Same as above.
generalize_branches(rule)	Same pattern, for droppable branches.	Same as above.

AST mutation helpers (the actual surgery)

Function	What it does	When it's used
_replace_table_in_ast(ast, target_value, target_name, placeholder_token)	Replaces every matching TableNode (and its qualified column refs) with placeholder_token. Bare-named refs to target_value are also matched even if their alias disagrees with target_name, so one variable can cover both an aliased outer reference and a bare-named reference inside a subquery.	Inside variablize_table.
_replace_column_in_ast(ast, column, external_name)	Renames every matching ColumnNode. Includes the *-capture quirk described above.	Inside variablize_column.
_replace_literal_in_ast(ast, literal, external_name, placeholder_token)	Substitutes literal occurrences. Strings rewritten in place via placeholder_token (preserving % wildcards); numeric literals swapped wholesale for an ElementVariableNode.	Inside variablize_literal.
_replace_subtree_in_ast(ast, subtree, replacement, parent=None)	Position-aware replacement. Only swaps a match when the parent context would have collected it as a candidate — so a column ref inside a JOIN ON is left alone even when the same column is replaced as a SELECT item.	Inside variablize_subtree.
_merge_variable_list_in_ast(ast, variable_set, set_name)	Collapses element variables into a single SetVariableNode(set_name). Handles SELECT/GROUP BY lists, AND chains (flattened first), single-WHERE predicates, JOIN ON, and LIMIT placeholders.	Inside merge_variable_list.
_drop_branch_in_ast(ast, branch)	Returns a new AST with the branch described by branch removed. Handles AND/OR conjunct removal (collapsing single-survivor chains), eq-RHS unwrapping, and per-clause QueryNode trimming with v1's wrapper-unwrap rules (e.g. dropping a sole FROM that wraps a subquery returns the inner query).	Inside drop_branch.
_query_without_clause(query, clause_type)	Returns a fresh QueryNode with one clause removed.	Inside _drop_branch_in_ast.
_replace_node_reference(root, target, replacement)	Splices replacement in for target everywhere it appears as a child within root. Re-syncs parent attribute aliases via _resync_parallel_attrs. Raises if target is root (parent can't rewire its own pointer).	Inside _replace_literal_in_ast for numeric replacement.
_resync_parallel_attrs(node, target, replacement)	Many AST nodes mirror children into named attributes (CaseNode.whens, WhenThenNode.when, JoinNode.on_condition, etc.). Whenever children mutates, this method walks the node's __dict__ and rewrites any pointer that is target to replacement.	Called after every list/set mutation in _replace_node_reference, _merge_variable_list_in_ast, _replace_subtree_in_ast.
_resync_join_attrs(join, had_on, n_using)	Re-syncs JoinNode.left_table, right_table, on_condition, and using from its current children list. Caller passes a snapshot of whether the join had an ON clause and how many USING columns existed before mutation.	Called by _merge_variable_list_in_ast and _replace_subtree_in_ast after recursing into a JoinNode.

Variable allocation

Function	What it does	When it's used
_find_next_element_variable(mapping)	Allocates the next unused element variable: returns (updated_mapping, "x?", "__rv_x?__"). Mutates mapping in place. The placeholder token is the parser-friendly form used when re-deparsing through mo_sql_parsing.	Every singular variablize_* and inside _expand_source_with_alias_vars.
_find_next_set_variable(mapping)	Same, for set variables: returns (updated_mapping, "y?", "__rvs_y?__").	Inside merge_variable_list.

---

Step 4 — Search

Goal: drive the generalization machinery to find one or many useful rules. Three strategies:

Function	What it does	When it's used
generate_general_rule(q0, q1)	Repeatedly applies all six generalize_* steps until the rule's fingerprint stops changing. Returns the most general rule reachable from the seed by exhaustively variablizing tables/columns/literals/subtrees, merging variable lists, and dropping branches.	Public API. The "give me the most general rule" entry point.
generate_rule_graph(q0, q1)	Builds the full BFS DAG of generalizations rooted at the seed rule. Each node's children list is populated with the rules reachable in one transformation step; nodes with the same fingerprint are deduplicated.	Public API. Used by the UI to let users browse the lattice of possible rules.
recommend_simple_rules(examples)	Picks a small set of generalized rules that together cover every (q0, q1) example. Generates candidate rules per example, fingerprints them, and greedy set-covers the still-uncovered examples; ties broken toward fewer variables.	Public API.
_recommendation_candidates(seed)	BFS expansion from a seed rule, capped at 256 candidates. Applies all six transforms repeatedly and dedupes by recommendation signature.	Inside recommend_simple_rules.
_recommendation_signature(rule)	Returns a structural signature repr((pattern_sig, rewrite_sig)) where every concrete table/alias is renamed to a stable token (T1, T2, A1, A2, …). Two rules that differ only in cosmetic naming share a signature.	Inside _recommendation_candidates for dedup.
_recommendation_ast_signature(node, state)	Recursive helper that builds the per-node signature tuple. Threads a state dict that maps real names to canonical tokens.	Inside _recommendation_signature.

---

Step 5 — Render & Identify

Goal: turn an AST back into SQL text (with <x>/<<y>> markers) and produce a stable identity for a rule. This is delicate because mo_sql_parsing won't tolerate <x> syntax mid-parse, so variables get round-tripped through placeholder tokens.

Render pipeline

Function	What it does	When it's used
deparse(node)	Renders a v2 AST node back into SQL text including <x>/<<y>> placeholders. Wraps a partial node into a full QueryNode for formatting, runs QueryFormatter, fixes mo_sql_parsing's NATURAL JOIN quirk, then strips the synthetic SELECT * FROM t WHERE … prefix to recover the original scope.	Called at the end of every singular variablize_* / merge_variable_list / drop_branch to refresh rule["pattern"] and rule["rewrite"]. Also used by fingerPrint and _subtrees_of_ast (for dedup keys).
dereplaceVars(sql, mapping)	Substitutes internal variable names back to user-facing markers (EV001 → <x>, SV001 → <<y>>).	Inside _parse_validate_impl to make parser error messages readable.
_extend_to_full_query(node)	Wraps a partial AST node into a full QueryNode so the formatter can render it. Returns (full_query, scope) where scope records what part of the synthetic wrapper to strip back off.	Inside deparse.
_extract_partial_sql(full_sql, scope)	The post-format strip step — removes the synthetic SELECT * , SELECT * FROM t , or SELECT * FROM t WHERE prefix based on scope.	Inside deparse.
_encode_vars_for_format(node)	Walks node, replaces every ElementVariableNode/SetVariableNode with a ColumnNode("__rv_x?__")/ColumnNode("__rvs_y?__"), and returns (node, placeholder_mapping). Variables-as-columns survive a round-trip through the formatter; the mapping lets us swap them back afterward.	Inside deparse, immediately before QueryFormatter().format.
_normalize_placeholder_tokens(sql)	Converts __rv_x?__ → <x?> and __rvs_y?__ → <<y?>> after the formatter has run.	Inside deparse.
_replace_wrapped_tokens(text, prefix, suffix, open, close)	Generic helper: finds prefix...suffix spans where the inner is [a-zA-Z0-9_]+ and replaces with open + inner + close.	Inside _normalize_placeholder_tokens.
_normalize_placeholder_numbers(text, start, end)	Strips numeric suffixes inside placeholder markers (<x7> → <x>).	Inside _fingerPrint.
_wrap_xy_identifiers(sql)	After variable round-trip, finds bare x?/y? tokens that aren't already inside <...> and wraps them. Skips contents of single-quoted strings.	Inside deparse.
_first_clause(query, node_type) / _query_has_clause(query, node_type)	Tiny helpers — return the first child of a QueryNode matching a given clause type (or a bool).	Inside _extend_to_full_query, _branch_entries_of_ast, _drop_branch_in_ast, _query_without_clause.

Identity / fingerprinting

Function	What it does	When it's used
fingerPrint(rule)	Returns a stable fingerprint string for rule based on its deparsed pattern. Variable indices are normalized so two rules that differ only in variable numbering share a fingerprint.	Used by generate_general_rule (fixed-point detection), generate_rule_graph (DAG dedup), and recommend_simple_rules (covering-set keys).
_fingerPrint(fingerprint)	The string-level normalization step: collapses <x7> → <x>, <<y3>> → <<y>>, and strips numeric suffixes.	Inside fingerPrint and _recommendation_ast_signature.
unify_variable_names(q0, q1)	Renumbers <x?>/<<x?>> placeholders in q0 and q1 consecutively in order of first appearance — <x9> and <x10> become <x1> and <x2> so two rules with equivalent placeholders compare equal as strings.	Public API. Used by callers comparing rules outside the AST.

Summary diagram

recommend_simple_rules(examples)        generate_rule_graph(q0, q1)        generate_general_rule(q0, q1)
        │                                       │                                  │
        │ per example                           │                                  │
        ▼                                       ▼                                  ▼
initialize_seed_rule(q0, q1) ◄─────────── Step 1: Seed ─────────────────────────► initialize_seed_rule
        │
        │   parse_validate / parse_validate_single
        │       └─ _parse_validate_impl
        │           ├─ _rule_parse_error_index
        │           ├─ _internal_variable_token_length_delta
        │           └─ _lev_distance
        │
        ▼
Step 2: Enumerate — what can be generalized?
        ├─ tables(p, r)         ← _tables_of_ast
        ├─ columns(p, r)        ← _walk
        ├─ literals(p, r)       ← _literal_counts
        ├─ subtrees(p, r)       ← _subtrees_of_ast → _is_subtree_candidate, _structural_key
        ├─ variable_lists(p, r) ← _variable_lists_of_ast
        └─ branches(p, r)       ← _branch_entries_of_ast → _is_branch_clause, _is_branch_node
                                                          → _branch_values_match → _branch_targets_match
        │
        ▼
Step 3: Generalize — apply transformations
        ├─ Singular: variablize_table / _column / _literal / _subtree
        │            merge_variable_list
        │            drop_branch
        │     │
        │     ├─ _find_next_element_variable / _find_next_set_variable
        │     ├─ _replace_table_in_ast       ┐
        │     ├─ _replace_column_in_ast      │
        │     ├─ _replace_literal_in_ast     ├─ all use _walk + _replace_node_reference
        │     ├─ _replace_subtree_in_ast     │     + _resync_parallel_attrs
        │     ├─ _merge_variable_list_in_ast │     + _resync_join_attrs
        │     ├─ _drop_branch_in_ast        ─┘     ← _query_without_clause
        │     └─ deparse  ← refresh rule["pattern"] / rule["rewrite"]
        │
        ├─ Plural (one child per candidate): variablize_tables / _columns / _literals
        │                                    / _subtrees / merge_variables / drop_branches
        │
        └─ One-pass: generalize_tables / _columns / _literals
                     / _subtrees / _variables / _branches  (driven by RuleGeneralizations tuple)
        │
        ▼
Step 4: Search — pick rule(s)
        ├─ generate_general_rule  → fixed-point loop on fingerPrint
        ├─ generate_rule_graph    → BFS DAG keyed by fingerPrint
        └─ recommend_simple_rules → greedy set cover
                                     ├─ _recommendation_candidates (≤256)
                                     ├─ _recommendation_signature
                                     │   └─ _recommendation_ast_signature
                                     └─ numberOfVariables (tie-break)
        │
        ▼
Step 5: Render & Identify
        ├─ deparse(node)
        │     ├─ _extend_to_full_query → _first_clause / _query_has_clause
        │     ├─ _encode_vars_for_format
        │     ├─ QueryFormatter.format
        │     ├─ _normalize_placeholder_tokens → _replace_wrapped_tokens
        │     ├─ _wrap_xy_identifiers
        │     └─ _extract_partial_sql
        │
        ├─ dereplaceVars(sql, mapping)   ← varType
        │
        └─ fingerPrint(rule) → _fingerPrint → _normalize_placeholder_numbers
           unify_variable_names(q0, q1)

[Copilot]

Pull request overview

This PR introduces an AST-backed RuleGeneratorV2, extends the SQL AST/parser/formatter stack for compound queries and JOIN ... USING/NATURAL JOIN, and adds a large v2-focused test suite. It fits into the rule-generation pipeline by moving rule generalization away from mo_sql_parsing JSON and onto first-class AST nodes.

Changes:

• Added core/rule_generator_v2.py with AST-based rule generalization, deparsing, validation, and recommendation helpers.
• Updated parser/formatter/AST code to carry CompoundQueryNode and JoinNode.using through parsing and formatting.
• Added get_rule_v2() plus a comprehensive tests/test_rule_generator_v2.py suite for the new generator.

Reviewed changes

Copilot reviewed 6 out of 7 changed files in this pull request and generated 4 comments.

Show a summary per file

File	Description
tests/test_rule_generator_v2.py	Adds extensive V2 rule-generator coverage and expected-rule fixtures.
data/rules.py	Adds get_rule_v2() for loading rules through the AST-based parser.
core/rule_parser_v2.py	Extends V2 rule parsing/substitution for compound queries, aliases, and join attributes.
core/rule_generator_v2.py	Introduces the new AST-based rule generalization engine.
core/query_parser.py	Adds parsing support for USING joins and natural joins.
core/query_formatter.py	Adds formatting support for compound queries, join USING, and variable nodes.
core/ast/node.py	Extends AST node models for literal aliases and join using columns.

---

💡 Add Copilot custom instructions for smarter, more guided reviews. Learn how to get started.