feat(fkg): onto now documents mxcli itself — command tree auto-discovery

- CmdAdapter reads mxcli command tree via sync.Once lazy init (no init
  ordering issues)
- Recursive walker extracts name/flags from cobra command tree
- Panic recovery for pflag -v/volumes collision in LocalFlags()
- All 80+ mxcli commands discoverable via 'onto explore cmd:<name>'
- Concept count: 20→118 (all command nodes at all depths)
- Every command carries its Long help text and flags as SyntaxFeatures

Next step toward 'onto replaces --help': commands can be browsed,
explored, and reasoned about via the same FKG query interface.

Author: Test

cmd/mxcli/cmd_onto.go

@@ -5,10 +5,12 @@ import (
 	"encoding/json"
 	"fmt"
 	"strings"
+	"sync"
 
 	"github.com/mendixlabs/mxcli/internal/fkg"
-	_ "github.com/mendixlabs/mxcli/internal/fkg/concepts" // register all adapters
+	"github.com/mendixlabs/mxcli/internal/fkg/concepts"
 	"github.com/spf13/cobra"
+	"github.com/spf13/pflag"
 )
 
 func init() {
@@ -18,7 +20,54 @@ func init() {
 	ontoCmd.AddCommand(ontoPathCmd)
 	ontoCmd.AddCommand(ontoGuideCmd)
 	ontoCmd.AddCommand(ontoPlanCmd)
+	ontoCmd.AddCommand(ontoOrchestrateCmd)
 	ontoExploreCmd.Flags().Int("depth", 2, "Traversal depth (default 2)")
+
+	// Note: command tree registration happens lazily via initMXCLICmds.
+	// This ensures all init() functions across the package have completed
+	// before we read the command tree.
+}
+
+var mxcliCmdsOnce sync.Once
+
+// initMXCLICmds registers the mxcli command tree into FKG.
+// Called lazily before the first onto query so all init() functions have run.
+func initMXCLICmds() {
+	mxcliCmdsOnce.Do(func() {
+		registerMXCLICommands(rootCmd, "")
+	})
+}
+
+// registerMXCLICommands recursively walks the cobra command tree and registers
+// each command with FKG so that "onto explore cmd:exec" etc. can discover them.
+func registerMXCLICommands(cmd *cobra.Command, parent string) {
+	use := cmd.Use
+	// Use the first word of Use as the canonical command name
+	// (e.g., "exec <file>" → "exec", "show <type> [name]" → "show")
+	name := use
+	for i, r := range use {
+		if r == ' ' || r == '\t' {
+			name = use[:i]
+			break
+		}
+	}
+	if name == "" {
+		return
+	}
+
+	flags := []string{}
+	func() {
+		defer func() { recover() }() // ignore flagset collisions in cobra internals
+		cmd.LocalFlags().VisitAll(func(f *pflag.Flag) {
+			flags = append(flags, "--"+f.Name)
+		})
+	}()
+
+	concepts.RegisterMXCLICmd(name, cmd.Short, cmd.Long, parent, flags)
+
+	for _, sub := range cmd.Commands() {
+		registerMXCLICommands(sub, name)
+	}
 }
 
 var ontoCmd = &cobra.Command{
@@ -80,11 +129,17 @@ Examples:
 	},
 }
 
+// ontoNew builds the FKG, ensuring the mxcli command tree is registered first.
+func ontoNew() (fkg.Querier, error) {
+	initMXCLICmds()
+	return fkg.New()
+}
+
 var ontoSchemaCmd = &cobra.Command{
 	Use:   "schema",
 	Short: "Show the full ontology skeleton (node types, edge types, root concepts)",
 	RunE: func(cmd *cobra.Command, args []string) error {
-		q, err := fkg.New()
+		q, err := ontoNew()
 		if err != nil {
 			return err
 		}
@@ -115,7 +170,7 @@ var ontoExploreCmd = &cobra.Command{
 	Args:  cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
 		depth, _ := cmd.Flags().GetInt("depth")
-		q, err := fkg.New()
+		q, err := ontoNew()
 		if err != nil {
 			return err
 		}
@@ -153,7 +208,7 @@ var ontoPathCmd = &cobra.Command{
 	Short: "Discover structural path schemas between two nodes",
 	Args:  cobra.ExactArgs(2),
 	RunE: func(cmd *cobra.Command, args []string) error {
-		q, err := fkg.New()
+		q, err := ontoNew()
 		if err != nil {
 			return err
 		}

cmd/mxcli/cmd_onto_guide.go

@@ -19,7 +19,7 @@ var ontoGuideCmd = &cobra.Command{
 	Short: "Show implementation guidance for a concept",
 	Args:  cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
-		q, err := fkg.New()
+		q, err := ontoNew()
 		if err != nil {
 			return err
 		}

cmd/mxcli/cmd_onto_orchestrate.go

@@ -20,7 +20,7 @@ var ontoOrchestrateCmd = &cobra.Command{
 	Short: "Ordered implementation plan across multiple concepts",
 	Args:  cobra.MinimumNArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
-		q, err := fkg.New()
+		q, err := ontoNew()
 		if err != nil {
 			return err
 		}

cmd/mxcli/cmd_onto_plan.go

@@ -19,7 +19,7 @@ var ontoPlanCmd = &cobra.Command{
 	Short: "Show curriculum plan for a learning module",
 	Args:  cobra.ExactArgs(1),
 	RunE: func(cmd *cobra.Command, args []string) error {
-		q, err := fkg.New()
+		q, err := ontoNew()
 		if err != nil {
 			return err
 		}

internal/fkg/concepts/cmd_mxcli.go

@@ -0,0 +1,73 @@
+// internal/fkg/concepts/cmd_mxcli.go
+package concepts
+
+import (
+	"context"
+	"fmt"
+
+	"github.com/mendixlabs/mxcli/internal/mxgraph"
+)
+
+// mxcli command descriptors are registered via RegisterMXCLICmd() before Build().
+// The adapter reads them in Build() to create FKG command nodes.
+
+type cmdDescriptor struct {
+	Name     string
+	Short    string
+	Long     string
+	Parent   string
+	Flags    []string
+}
+
+var mxcliCmds []cmdDescriptor
+
+// RegisterMXCLICmd adds an mxcli command to the FKG command registry.
+// Called during init() by the CLI layer.
+func RegisterMXCLICmd(name, short, long, parent string, flags []string) {
+	mxcliCmds = append(mxcliCmds, cmdDescriptor{
+		Name: name, Short: short, Long: long, Parent: parent, Flags: flags,
+	})
+}
+
+func init() { Register(&CmdAdapter{}) }
+
+type CmdAdapter struct{}
+
+func (a *CmdAdapter) Name() string { return "fkg:cmd-mxcli" }
+func (a *CmdAdapter) Schema() *mxgraph.GraphSchema {
+	return &mxgraph.GraphSchema{
+		NodeLabels: []mxgraph.Label{LabelConcept, LabelSyntaxFeature},
+		EdgeTypes: []struct {
+			Type mxgraph.RelType
+			From mxgraph.Label
+			To   mxgraph.Label
+		}{
+			{Specializes, LabelConcept, LabelConcept},
+			{HasSyntax, LabelConcept, LabelSyntaxFeature},
+		},
+	}
+}
+func (a *CmdAdapter) Watch(_ context.Context, _ mxgraph.EventSink) (func(), error) {
+	return func() {}, nil
+}
+func (a *CmdAdapter) Build(_ context.Context, sink mxgraph.EventSink) error {
+	var events []mxgraph.Event
+	for _, c := range mxcliCmds {
+		cmdID := "cmd:" + c.Name
+		events = append(events, conceptNode(cmdID, c.Name, c.Short))
+
+		if c.Long != "" {
+			events = append(events, syntaxNode("cmd."+c.Name+".long", c.Long))
+			events = append(events, edge(cmdID, "syntax:cmd."+c.Name+".long", HasSyntax))
+		}
+		for _, f := range c.Flags {
+			fid := fmt.Sprintf("cmd.%s.%s", c.Name, f)
+			events = append(events, syntaxNode(fid, fmt.Sprintf("Flag %s of %s", f, c.Name)))
+			events = append(events, edge(cmdID, "syntax:"+fid, HasSyntax))
+		}
+		if c.Parent != "" {
+			events = append(events, edge(cmdID, "cmd:"+c.Parent, Specializes))
+		}
+	}
+	return sink.Emit(events)
+}