Function newMemoryWriteCommand

internal/cli/memory.go:227–298

(deps commandDeps)

}

func newMemoryWriteCommand(deps commandDeps) *cobra.Command {
	var flags memorySelectorFlags
	var typeRaw string
	var name string
	var description string
	var contentFlag string
	var dryRun bool

	cmd := &cobra.Command{
		Use:   "write --type <type> --name <name> --content <@file|text>",
		Short: "Create a Memory v2 entry through the controller",
		Example: `  # Write workspace-scoped project memory from a file
  agh memory write --scope workspace --type project --name "Runtime docs" --content @runtime.md

  # Write agent-global feedback
  agh memory write --scope agent --agent reviewer --agent-tier global \
    --type feedback --name "Review tone" --content @feedback.md`,
		Args: cobra.NoArgs,
		RunE: func(cmd *cobra.Command, _ []string) error {
			client, err := clientFromDeps(deps)
			if err != nil {
				return err
			}
			typ, err := parseRequiredMemoryType(typeRaw)
			if err != nil {
				return err
			}
			defaultScope, err := memcontract.DefaultScopeForType(typ)
			if err != nil {
				return err
			}
			selector, err := resolveMemorySelectorFlags(deps, flags, memorySelectorOptions{DefaultScope: defaultScope})
			if err != nil {
				return err
			}
			content, err := resolveMemoryContent(cmd, deps, contentFlag)
			if err != nil {
				return err
			}
			if strings.TrimSpace(name) == "" {
				return errors.New("memory.name_required: --name is required")
			}
			response, err := client.CreateMemory(cmd.Context(), MemoryCreateRequest{
				Scope:       selector.Scope,
				WorkspaceID: selector.WorkspaceID,
				AgentName:   selector.AgentName,
				AgentTier:   selector.AgentTier,
				Origin:      memcontract.OriginCLI,
				Type:        typ,
				Name:        strings.TrimSpace(name),
				Description: strings.TrimSpace(description),
				Content:     content,
				DryRun:      dryRun,
			})
			if err != nil {
				return err
			}
			return writeCommandOutput(cmd, memoryMutationBundle("Memory Write", response))