add repo in sdk and modify commands internal

Author: systemshift

pkg/sdk/commands.go

@@ -1,6 +1,9 @@
 package sdk
 
-import "memex/pkg/types"
+import (
+	"fmt"
+	"memex/pkg/types"
+)
 
 // CommandBuilder helps build commands with a fluent interface
 type CommandBuilder struct {
@@ -39,48 +42,111 @@ func (b *CommandBuilder) Build() types.Command {
 	return b.cmd
 }
 
+// CommandHandler represents a function that handles a command
+type CommandHandler func(repo types.Repository, args []string) error
+
+// CommandSet represents a set of commands with their handlers
+type CommandSet struct {
+	commands map[string]types.Command
+	handlers map[string]CommandHandler
+}
+
+// NewCommandSet creates a new command set
+func NewCommandSet() *CommandSet {
+	return &CommandSet{
+		commands: make(map[string]types.Command),
+		handlers: make(map[string]CommandHandler),
+	}
+}
+
+// Add adds a command and its handler to the set
+func (cs *CommandSet) Add(cmd types.Command, handler CommandHandler) {
+	cs.commands[cmd.Name] = cmd
+	cs.handlers[cmd.Name] = handler
+}
+
+// Get returns a command and its handler by name
+func (cs *CommandSet) Get(name string) (types.Command, CommandHandler, bool) {
+	cmd, exists := cs.commands[name]
+	if !exists {
+		return types.Command{}, nil, false
+	}
+	return cmd, cs.handlers[name], true
+}
+
+// List returns all commands in the set
+func (cs *CommandSet) List() []types.Command {
+	cmds := make([]types.Command, 0, len(cs.commands))
+	for _, cmd := range cs.commands {
+		cmds = append(cmds, cmd)
+	}
+	return cmds
+}
+
+// Handle executes a command with the given arguments
+func (cs *CommandSet) Handle(repo types.Repository, cmd string, args []string) error {
+	_, handler, exists := cs.Get(cmd)
+	if !exists {
+		return fmt.Errorf("%w: command %s", ErrNotFound, cmd)
+	}
+	return handler(repo, args)
+}
+
 // Common command patterns
 
 // NewAddCommand creates a standard add command
-func NewAddCommand(itemType string) types.Command {
-	return NewCommand("add").
+func NewAddCommand(itemType string, handler CommandHandler) (types.Command, CommandHandler) {
+	cmd := NewCommand("add").
 		WithDescription("Add " + itemType).
 		WithUsage("add <" + itemType + ">").
 		WithArgs(itemType).
 		Build()
+	return cmd, handler
 }
 
 // NewListCommand creates a standard list command
-func NewListCommand(itemType string) types.Command {
-	return NewCommand("list").
+func NewListCommand(itemType string, handler CommandHandler) (types.Command, CommandHandler) {
+	cmd := NewCommand("list").
 		WithDescription("List " + itemType + "s").
 		WithUsage("list [filter]").
 		Build()
+	return cmd, handler
 }
 
 // NewRemoveCommand creates a standard remove command
-func NewRemoveCommand(itemType string) types.Command {
-	return NewCommand("remove").
+func NewRemoveCommand(itemType string, handler CommandHandler) (types.Command, CommandHandler) {
+	cmd := NewCommand("remove").
 		WithDescription("Remove " + itemType).
 		WithUsage("remove <" + itemType + ">").
 		WithArgs(itemType).
 		Build()
+	return cmd, handler
 }
 
 // NewShowCommand creates a standard show command
-func NewShowCommand(itemType string) types.Command {
-	return NewCommand("show").
+func NewShowCommand(itemType string, handler CommandHandler) (types.Command, CommandHandler) {
+	cmd := NewCommand("show").
 		WithDescription("Show " + itemType + " details").
 		WithUsage("show <" + itemType + ">").
 		WithArgs(itemType).
 		Build()
+	return cmd, handler
 }
 
 // NewUpdateCommand creates a standard update command
-func NewUpdateCommand(itemType string) types.Command {
-	return NewCommand("update").
+func NewUpdateCommand(itemType string, handler CommandHandler) (types.Command, CommandHandler) {
+	cmd := NewCommand("update").
 		WithDescription("Update " + itemType).
 		WithUsage("update <" + itemType + "> [options]").
 		WithArgs(itemType).
 		Build()
+	return cmd, handler
+}
+
+// ValidateArgs validates command arguments
+func ValidateArgs(cmd types.Command, args []string) error {
+	if len(args) < len(cmd.Args) {
+		return fmt.Errorf("%w: missing required arguments: %v", ErrInvalidInput, cmd.Args[len(args):])
+	}
+	return nil
 }

pkg/sdk/repository.go

@@ -0,0 +1,90 @@
+package sdk
+
+import (
+	"fmt"
+
+	"memex/pkg/types"
+)
+
+// RepositoryHelper provides common repository operations for modules
+type RepositoryHelper struct {
+	repo types.Repository
+}
+
+// NewRepositoryHelper creates a new repository helper
+func NewRepositoryHelper(repo types.Repository) *RepositoryHelper {
+	return &RepositoryHelper{repo: repo}
+}
+
+// AddNodeWithMeta adds a node with module metadata
+func (h *RepositoryHelper) AddNodeWithMeta(content []byte, nodeType string, moduleID string, meta map[string]interface{}) (string, error) {
+	if meta == nil {
+		meta = make(map[string]interface{})
+	}
+	meta["module"] = moduleID
+	return h.repo.AddNode(content, nodeType, meta)
+}
+
+// GetModuleNodes returns all nodes created by a module
+func (h *RepositoryHelper) GetModuleNodes(moduleID string) ([]*types.Node, error) {
+	return h.repo.QueryNodesByModule(moduleID)
+}
+
+// GetModuleLinks returns all links created by a module
+func (h *RepositoryHelper) GetModuleLinks(moduleID string) ([]*types.Link, error) {
+	return h.repo.QueryLinksByModule(moduleID)
+}
+
+// AddModuleLink adds a link with module metadata
+func (h *RepositoryHelper) AddModuleLink(source, target, linkType string, moduleID string, meta map[string]interface{}) error {
+	if meta == nil {
+		meta = make(map[string]interface{})
+	}
+	meta["module"] = moduleID
+	return h.repo.AddLink(source, target, linkType, meta)
+}
+
+// DeleteModuleNodes deletes all nodes created by a module
+func (h *RepositoryHelper) DeleteModuleNodes(moduleID string) error {
+	nodes, err := h.repo.QueryNodesByModule(moduleID)
+	if err != nil {
+		return fmt.Errorf("querying module nodes: %w", err)
+	}
+
+	for _, node := range nodes {
+		if err := h.repo.DeleteNode(node.ID); err != nil {
+			return fmt.Errorf("deleting node %s: %w", node.ID, err)
+		}
+	}
+
+	return nil
+}
+
+// DeleteModuleLinks deletes all links created by a module
+func (h *RepositoryHelper) DeleteModuleLinks(moduleID string) error {
+	links, err := h.repo.QueryLinksByModule(moduleID)
+	if err != nil {
+		return fmt.Errorf("querying module links: %w", err)
+	}
+
+	for _, link := range links {
+		if err := h.repo.DeleteLink(link.Source, link.Target, link.Type); err != nil {
+			return fmt.Errorf("deleting link %s -> %s: %w", link.Source, link.Target, err)
+		}
+	}
+
+	return nil
+}
+
+// CleanupModule removes all nodes and links created by a module
+func (h *RepositoryHelper) CleanupModule(moduleID string) error {
+	if err := h.DeleteModuleLinks(moduleID); err != nil {
+		return fmt.Errorf("deleting module links: %w", err)
+	}
+
+	if err := h.DeleteModuleNodes(moduleID); err != nil {
+		return fmt.Errorf("deleting module nodes: %w", err)
+	}
+
+	return nil
+}