create module manager in /interna/ expose and simplify pkg/

Author: systemshift

internal/memex/core/types.go

@@ -66,15 +66,6 @@ type Repository interface {
 	GetLinks(nodeID string) ([]*Link, error)
 	DeleteLink(source, target, linkType string) error
 
-	// Module operations
-	ListModules() []Module
-	GetModule(id string) (Module, bool)
-	RegisterModule(module Module) error
-
-	// Query operations
-	QueryNodesByModule(moduleID string) ([]*Node, error)
-	QueryLinksByModule(moduleID string) ([]*Link, error)
-
 	// Close closes the repository
 	Close() error
 }

internal/memex/modules.go

@@ -0,0 +1,30 @@
+package memex
+
+import (
+	"github.com/systemshift/memex/internal/memex/core"
+)
+
+var (
+	// Global module registry
+	moduleRegistry = NewRegistry()
+)
+
+// RegisterModule registers a module globally
+func RegisterModule(module core.Module) error {
+	return moduleRegistry.RegisterModule(module)
+}
+
+// GetModule returns a module by ID
+func GetModule(id string) (core.Module, bool) {
+	return moduleRegistry.GetModule(id)
+}
+
+// ListModules returns all registered modules
+func ListModules() []core.Module {
+	return moduleRegistry.ListModules()
+}
+
+// HandleModuleCommand executes a module command
+func HandleModuleCommand(moduleID string, cmd string, args []string, repo core.Repository) error {
+	return moduleRegistry.HandleCommand(moduleID, cmd, args, repo)
+}

internal/memex/registry.go

@@ -0,0 +1,70 @@
+package memex
+
+import (
+	"fmt"
+	"sync"
+
+	"github.com/systemshift/memex/internal/memex/core"
+)
+
+// Registry manages registered modules
+type Registry struct {
+	modules map[string]core.Module
+	mu      sync.RWMutex
+}
+
+// NewRegistry creates a new module registry
+func NewRegistry() *Registry {
+	return &Registry{
+		modules: make(map[string]core.Module),
+	}
+}
+
+// RegisterModule registers a module
+func (r *Registry) RegisterModule(module core.Module) error {
+	r.mu.Lock()
+	defer r.mu.Unlock()
+
+	if _, exists := r.modules[module.ID()]; exists {
+		return fmt.Errorf("module already registered: %s", module.ID())
+	}
+
+	r.modules[module.ID()] = module
+	return nil
+}
+
+// GetModule returns a module by ID
+func (r *Registry) GetModule(id string) (core.Module, bool) {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	module, exists := r.modules[id]
+	return module, exists
+}
+
+// ListModules returns all registered modules
+func (r *Registry) ListModules() []core.Module {
+	r.mu.RLock()
+	defer r.mu.RUnlock()
+
+	result := make([]core.Module, 0, len(r.modules))
+	for _, mod := range r.modules {
+		result = append(result, mod)
+	}
+	return result
+}
+
+// HandleCommand executes a module command
+func (r *Registry) HandleCommand(moduleID string, cmd string, args []string, repo core.Repository) error {
+	module, exists := r.GetModule(moduleID)
+	if !exists {
+		return fmt.Errorf("module not found: %s", moduleID)
+	}
+
+	// Initialize module with repository if needed
+	if err := module.Init(repo); err != nil {
+		return fmt.Errorf("initializing module: %w", err)
+	}
+
+	return module.HandleCommand(cmd, args)
+}

pkg/memex/commands.go

@@ -2,6 +2,7 @@ package memex
 
 import (
 	"fmt"
+
 	"github.com/systemshift/memex/internal/memex"
 )
 
@@ -114,12 +115,7 @@ func (c *Commands) Module(args ...string) error {
 
 // ModuleHelp shows help for a module
 func (c *Commands) ModuleHelp(moduleID string) error {
-	repo, err := memex.GetRepository()
-	if err != nil {
-		return fmt.Errorf("getting repository: %w", err)
-	}
-
-	mod, exists := repo.GetModule(moduleID)
+	mod, exists := memex.GetModule(moduleID)
 	if !exists {
 		return fmt.Errorf("module not found: %s", moduleID)
 	}

pkg/memex/memex.go

@@ -3,6 +3,7 @@ package memex
 import (
 	"fmt"
 
+	internalmemex "github.com/systemshift/memex/internal/memex"
 	"github.com/systemshift/memex/internal/memex/core"
 	"github.com/systemshift/memex/internal/memex/repository"
 )
@@ -111,57 +112,20 @@ func (m *Memex) GetContent(id string) ([]byte, error) {
 
 // RegisterModule registers a new module
 func (m *Memex) RegisterModule(mod core.Module) error {
-	return m.repo.RegisterModule(mod)
+	return internalmemex.RegisterModule(mod)
 }
 
 // GetModule returns a module by ID
 func (m *Memex) GetModule(id string) (core.Module, bool) {
-	return m.repo.GetModule(id)
+	return internalmemex.GetModule(id)
 }
 
 // ListModules returns all registered modules
 func (m *Memex) ListModules() []core.Module {
-	return m.repo.ListModules()
+	return internalmemex.ListModules()
 }
 
-// QueryNodesByModule returns all nodes created by a module
-func (m *Memex) QueryNodesByModule(moduleID string) ([]*Node, error) {
-	nodes, err := m.repo.QueryNodesByModule(moduleID)
-	if err != nil {
-		return nil, err
-	}
-
-	result := make([]*Node, len(nodes))
-	for i, node := range nodes {
-		result[i] = &Node{
-			ID:       node.ID,
-			Type:     node.Type,
-			Content:  node.Content,
-			Meta:     node.Meta,
-			Created:  node.Created,
-			Modified: node.Modified,
-		}
-	}
-	return result, nil
-}
-
-// QueryLinksByModule returns all links created by a module
-func (m *Memex) QueryLinksByModule(moduleID string) ([]*Link, error) {
-	links, err := m.repo.QueryLinksByModule(moduleID)
-	if err != nil {
-		return nil, err
-	}
-
-	result := make([]*Link, len(links))
-	for i, link := range links {
-		result[i] = &Link{
-			Source:   link.Source,
-			Target:   link.Target,
-			Type:     link.Type,
-			Meta:     link.Meta,
-			Created:  link.Created,
-			Modified: link.Modified,
-		}
-	}
-	return result, nil
+// HandleModuleCommand executes a module command
+func (m *Memex) HandleModuleCommand(moduleID string, cmd string, args []string) error {
+	return internalmemex.HandleModuleCommand(moduleID, cmd, args, m.repo)
 }

pkg/module/module.go

@@ -16,11 +16,6 @@ type (
 	Repository = core.Repository
 )
 
-// Common errors
-var (
-	ErrNotInitialized = core.ErrNotInitialized
-)
-
 // Base provides a base implementation of Module interface
 type Base struct {
 	id          string
@@ -63,29 +58,12 @@ func (b *Base) Init(repo Repository) error {
 
 // Commands returns the list of available commands
 func (b *Base) Commands() []Command {
-	baseCommands := []Command{
-		{
-			Name:        "help",
-			Description: "Show module help",
-		},
-		{
-			Name:        "version",
-			Description: "Show module version",
-		},
-	}
-	return append(baseCommands, b.commands...)
+	return b.commands
 }
 
 // HandleCommand handles a module command
 func (b *Base) HandleCommand(cmd string, args []string) error {
-	switch cmd {
-	case "help":
-		return nil // Let the CLI handle help
-	case "version":
-		return nil // Let the CLI handle version
-	default:
-		return fmt.Errorf("unknown command: %s", cmd)
-	}
+	return fmt.Errorf("unknown command: %s", cmd)
 }
 
 // AddCommand adds a command to the module
@@ -98,31 +76,31 @@ func (b *Base) AddCommand(cmd Command) {
 // AddNode adds a node to the repository
 func (b *Base) AddNode(content []byte, nodeType string, meta map[string]interface{}) (string, error) {
 	if b.repo == nil {
-		return "", ErrNotInitialized
+		return "", fmt.Errorf("module not initialized")
 	}
 	return b.repo.AddNode(content, nodeType, meta)
 }
 
 // GetNode gets a node from the repository
 func (b *Base) GetNode(id string) (*Node, error) {
 	if b.repo == nil {
-		return nil, ErrNotInitialized
+		return nil, fmt.Errorf("module not initialized")
 	}
 	return b.repo.GetNode(id)
 }
 
 // AddLink adds a link between nodes
 func (b *Base) AddLink(source, target, linkType string, meta map[string]interface{}) error {
 	if b.repo == nil {
-		return ErrNotInitialized
+		return fmt.Errorf("module not initialized")
 	}
 	return b.repo.AddLink(source, target, linkType, meta)
 }
 
 // GetLinks gets links for a node
 func (b *Base) GetLinks(nodeID string) ([]*Link, error) {
 	if b.repo == nil {
-		return nil, ErrNotInitialized
+		return nil, fmt.Errorf("module not initialized")
 	}
 	return b.repo.GetLinks(nodeID)
 }