M7: extract pure CCFE::Action parser, de-dup do_menu/do_form

The action-string parse -- `VERB[(opt,...)]:ARGS` into verb, option list
and raw argument string -- was the same five-line split/regex duplicated
at the do_menu and do_form call sites. Lift it into a pure, terminal-free
CCFE::Action module; both sites now call CCFE::Action::parse.

The dispatch stays in ccfe.pl, where it belongs: running the verb,
drawing the `confirm` list, honouring `log`/`wait_key`, and spawning the
command are all effectful. The head is leading-whitespace-trimmed before
matching (as do_form already did, a no-op for the already-trimmed menu
actions), and a malformed head yields verb => undef so the caller's verb
dispatch simply finds no match -- behaviour unchanged at both sites.

Unit-tested in t/16-action.t (23 cases); the menu/form tty tests and the
full suite (now 275 tests) stay green. All four CI checks pass locally
(compile, prove, perlcritic src/lib, perltidy).

Co-Authored-By: Claude Opus 4.8 (1M context) <noreply@anthropic.com>

Author: claude

ROADMAP.md

@@ -185,8 +185,14 @@ the conformance tests.
   plus term-specific (`FIELD_ATTR.$TERM`) and `$COLS`-dependent handling -- so
   that (effectful, scope-bound) dispatch stays in `load_config` verbatim. Unit-
   tested in `t/15-config.t` (17 cases); the colour/theme integration test
-  (`t/06-color.t`) and full suite (252 tests) stay green. Next: `Action`, the
-  pure `Layout` helpers, and finally the `$ctx` threading.
+  (`t/06-color.t`) and full suite (252 tests) stay green.
+- 🔄 **`CCFE::Action`** (done): the action-string parse (`VERB[(opts)]:ARGS` ->
+  `{verb, opts, args}`) -- the same five-line split/regex duplicated in
+  `do_menu` and `do_form` -- is now a pure module. The dispatch (running the
+  verb, prompting for `confirm`, honouring `log`/`wait_key`, spawning commands)
+  stays in `ccfe.pl` as it draws lists and runs processes. Unit-tested in
+  `t/16-action.t` (23 cases); the menu/form tty tests and full suite (275 tests)
+  stay green. Next: the pure `Layout` helpers, and finally the `$ctx` threading.
 
 ## M8 — Non-functional close-out audit  _(final gate)_
 Five dimensions: **test coverage, code quality, performance, security,

src/ccfe.pl

@@ -49,6 +49,7 @@
 use CCFE::MenuFile ();    # pure .menu/.item parser (see load_menu)
 use CCFE::FormFile ();    # pure .form parser (see load_form)
 use CCFE::Config   ();    # pure .conf section tokenizer (see load_config)
+use CCFE::Action   ();    # pure action-string parser (see do_menu/do_form)
 use FindBin ();    # to locate the program at runtime (see the path block below)
 
 # Optional display-width support.  In a UTF-8 locale a label/title can occupy
@@ -2121,12 +2122,10 @@ sub do_menu {
                 $ci           = item_index( current_item($cmenu) );
                 $last_item_id = $menu{items}[$ci]{id};
                 if ( $menu{items}[$ci]{action} ) {
-                    ( $action, $args ) = split /:/, $menu{items}[$ci]{action},
-                      2;
-                    $action = lc $action;
-                    $action =~ /^([a-zA-Z]+)\(?([a-zA-Z_,]*)\)?$/;
-                    $action = $1;
-                    @actopts = split /,\s*/, $2;
+                    my $act = CCFE::Action::parse( $menu{items}[$ci]{action} );
+                    $action  = $act->{verb};
+                    $args    = $act->{args};
+                    @actopts = @{ $act->{opts} };
 
                     $wait_key      = $NO;
                     $LOG_REQUESTED = $NO;
@@ -3663,13 +3662,10 @@ sub do_form {
                 }
 
                 unless ($empty_required) {
-                    ( $action, $args ) = split /:/, $form{action}, 2;
-                    $action =~ s/^\s+//;
-                    $action = lc $action;
-
-                    $action =~ /^([a-zA-Z]+)\(?([a-zA-Z_,]*)\)?$/;
-                    $action = $1;
-                    @actopts = split /,\s*/, $2;
+                    my $act = CCFE::Action::parse( $form{action} );
+                    $action  = $act->{verb};
+                    $args    = $act->{args};
+                    @actopts = @{ $act->{opts} };
 
                     $wait_key      = $NO;
                     $LOG_REQUESTED = $NO;

src/lib/CCFE/Action.pm

@@ -0,0 +1,43 @@
+package CCFE::Action;
+
+# Pure parser for a CCFE action string (ROADMAP M7, REFACTOR.md §3).
+#
+# An action string is `VERB[(opt,opt,...)]:ARGS` -- e.g. "run:ls -l",
+# "menu:submenu", "system(confirm,wait_key):reboot".  parse() splits it into
+# its verb, its option list and its raw argument string, with no terminal and
+# no globals.  do_menu()/do_form() in ccfe.pl own the dispatch -- running the
+# verb, prompting for `confirm`, honouring `log`/`wait_key` -- which is
+# effectful (it draws confirmation lists and spawns commands) and stays there.
+# This was the same five-line parse duplicated at both call sites.
+#
+# parse($str) returns a hashref:
+#   { verb => 'run',              # lower-cased; undef if the head is malformed
+#     opts => [ 'confirm', ... ], # option names, in order (possibly empty)
+#     args => 'ls -l' }           # everything after the first ':', verbatim
+#                                 # (undef if the string carried no ':')
+#
+# The head is leading-whitespace-trimmed before matching (as do_form already
+# did, and a no-op for menu actions, which the .menu parser trims).  A head
+# that is not `word` or `word(opts)` yields verb => undef, opts => [] -- the
+# caller's verb dispatch then simply finds no match, exactly as before.
+
+use v5.36;
+
+our $VERSION = '2.1';
+
+sub parse ($str) {
+    my ( $head, $args ) = split /:/, $str // '', 2;
+    $head //= '';
+    $head =~ s/^\s+//;
+    $head = lc $head;
+
+    my ( $verb, $optstr );
+    if ( $head =~ /^([a-zA-Z]+)\(?([a-zA-Z_,]*)\)?$/ ) {
+        $verb   = $1;
+        $optstr = $2;
+    }
+    my @opts = defined $optstr ? split( /,\s*/, $optstr ) : ();
+    return { verb => $verb, opts => \@opts, args => $args };
+}
+
+1;

src/t/16-action.t

@@ -0,0 +1,68 @@
+#!/usr/bin/perl
+#
+# Unit tests for the pure CCFE::Action parser (ROADMAP M7).
+#
+# An action string `VERB[(opt,opt,...)]:ARGS` was parsed by the same five-line
+# split/regex duplicated in do_menu() and do_form().  That parse is now a pure
+# module; the dispatch (running the verb, prompting for `confirm`, honouring
+# `log`/`wait_key`) stays in ccfe.pl.  These drive parse($str) directly.
+#
+use strict;
+use warnings;
+use FindBin qw($Bin);
+use lib "$Bin/../lib";
+use Test::More;
+
+require_ok('CCFE::Action') or BAIL_OUT('cannot load CCFE::Action');
+
+# ---- a plain verb:args --------------------------------------------------
+my $a = CCFE::Action::parse('run:ls -l /tmp');
+is( $a->{verb}, 'run',        'verb captured' );
+is( $a->{args}, 'ls -l /tmp', '  args captured verbatim (incl. spaces)' );
+is_deeply( $a->{opts}, [], '  no options' );
+
+# ---- only the first colon splits verb from args -------------------------
+$a = CCFE::Action::parse('run:ssh host:cmd');
+is( $a->{verb}, 'run',          'first colon splits' );
+is( $a->{args}, 'ssh host:cmd', '  later colons stay in args' );
+
+# ---- the verb is lower-cased --------------------------------------------
+$a = CCFE::Action::parse('MENU:sub');
+is( $a->{verb}, 'menu', 'verb is lower-cased' );
+is( $a->{args}, 'sub',  '  args kept as-is' );
+
+# ---- options in parentheses ---------------------------------------------
+$a = CCFE::Action::parse('system(confirm,wait_key):reboot');
+is( $a->{verb}, 'system', 'verb with options' );
+is_deeply( $a->{opts}, [ 'confirm', 'wait_key' ], '  options split in order' );
+is( $a->{args}, 'reboot', '  args after the option list' );
+
+# ---- a single option ----------------------------------------------------
+$a = CCFE::Action::parse('run(log):make');
+is_deeply( $a->{opts}, ['log'], 'a single option parses' );
+is( $a->{verb}, 'run',  '  verb still captured' );
+is( $a->{args}, 'make', '  args still captured' );
+
+# ---- a verb with no args (no colon) -------------------------------------
+$a = CCFE::Action::parse('back');
+is( $a->{verb}, 'back',  'a bare verb parses' );
+is( $a->{args}, undef,   '  args is undef when there is no colon' );
+is_deeply( $a->{opts}, [], '  no options' );
+
+# ---- leading whitespace on the head is trimmed --------------------------
+$a = CCFE::Action::parse('  run:x');
+is( $a->{verb}, 'run', 'leading whitespace before the verb is trimmed' );
+
+# ---- a malformed head yields an undef verb (caller finds no match) -------
+$a = CCFE::Action::parse('123bad:x');
+is( $a->{verb}, undef, 'a head that is not word/word(opts) -> undef verb' );
+is( $a->{args}, 'x',   '  args still returned' );
+is_deeply( $a->{opts}, [], '  no options' );
+
+# ---- empty / undef input is safe ----------------------------------------
+$a = CCFE::Action::parse('');
+is( $a->{verb}, undef, 'empty string -> undef verb' );
+$a = CCFE::Action::parse(undef);
+is( $a->{verb}, undef, 'undef input -> undef verb (no warning/crash)' );
+
+done_testing();